hjimmy/tg-origin: source/pkg/route/controller/ingress/ingress.go; 27 LoC

Found a possible issue in [hjimmy/tg-origin](https://www.github.com/hjimmy/tg-origin) at [source/pkg/route/controller/ingress/ingress.go](https://github.com/hjimmy/tg-origin/blob/07e45cb8ec631f158f6c7c29330a9cdeae9f4a29/source/pkg/route/controller/ingress/ingress.go#L391-L417)

Below is the message reported by the analyzer for this snippet of code. Beware that the analyzer only reports the first issue it finds, so please do not limit your consideration to the contents of the below message.

> function call which takes a reference to path at line 405 may start a goroutine

[Click here to see the code in its original context.](https://github.com/hjimmy/tg-origin/blob/07e45cb8ec631f158f6c7c29330a9cdeae9f4a29/source/pkg/route/controller/ingress/ingress.go#L391-L417)

Click here to show the 27 line(s) of Go which triggered the analyzer.

```go
for _, path := range rule.HTTP.Paths {
if len(path.Backend.ServiceName) == 0 {
continue
}

var existing *routev1.Route
old, existing = splitForPathAndHost(old, rule.Host, path.Path)
if existing == nil {
if r := newRouteForIngress(ingress, &rule, &path, c.secretLister, c.serviceLister); r != nil {
creates = append(creates, r)
}
continue
}

if routeMatchesIngress(existing, ingress, &rule, &path, c.secretLister, c.serviceLister) {
continue
}

if r := newRouteForIngress(ingress, &rule, &path, c.secretLister, c.serviceLister); r != nil {
// merge the relevant spec pieces
preserveRouteAttributesFromExisting(r, existing)
updates = append(updates, r)
} else {
// the route cannot be fully calculated, delete it
old = append(old, existing)
}
}

```

Click here to show extra information the analyzer produced.

```
The following graphviz dot graph describes paths through the callgraph that could lead to a function calling a goroutine:
digraph G {
"(newClient, 1)" -> {"(dial, 2)";}
"(stop, 1)" -> {}
"(forward, 3)" -> {}
"(Update, 3)" -> {"(add, 1)";}
"(RunSnap, 2)" -> {"(snap, 2)";}
"(newServerTransport, 4)" -> {}
"(setUp, 1)" -> {"(NewUnsecuredEtcd3TestClientServer, 1)";}
"(Validate, 2)" -> {}
"(Do, 1)" -> {"(Open, 2)";"(Prepare, 3)";"(Prepare, 2)";}
"(NewClient, 1)" -> {"(newClient, 1)";}
"(fetch, 1)" -> {"(add, 2)";}
"(DetachDisk, 3)" -> {"(Run, 3)";}
"(update, 1)" -> {"(UpdatePod, 2)";}
"(startKubelet, 5)" -> {}
"(Limit, 3)" -> {"(update, 1)";}
"(WaitForRunningDeployerPod, 3)" -> {"(Watch, 1)";}
"(StartNode, 2)" -> {}
"(getRange, 1)" -> {"(Index, 2)";}
"(addConnIfNeeded, 3)" -> {}
"(Do, 2)" -> {"(Write, 1)";"(Put, 2)";"(Do, 1)";"(Execute, 2)";"(Put, 3)";"(RoundTrip, 1)";"(Delete, 2)";}
"(Set, 2)" -> {"(Put, 3)";"(Do, 3)";}
"(NewSSHTunnelList, 4)" -> {}
"(SetTransportDefaults, 1)" -> {"(ConfigureTransport, 1)";}
"(get, 2)" -> {"(Do, 2)";"(Get, 3)";}
"(wrapTLS, 4)" -> {"(newTLSListener, 2)";}
"(Unmarshal, 2)" -> {"(Add, 1)";"(Set, 1)";"(Put, 1)";"(Get, 0)";}
"(add, 2)" -> {"(add, 1)";}
"(watch, 3)" -> {"(Watch, 1)";}
"(NewServerConn, 2)" -> {"(serverHandshake, 1)";}
"(Close, 1)" -> {"(Dispatch, 3)";}
"(Dispatch, 3)" -> {}
"(Put, 1)" -> {"(Write, 1)";"(Create, 1)";"(Put, 3)";}
"(send, 1)" -> {"(post, 1)";}
"(Launch, 1)" -> {}
"(Start, 2)" -> {"(initializeAndStartHeartbeat, 4)";"(callRemoteBalancer, 2)";}
"(load, 1)" -> {"(parsePackageFiles, 2)";}
"(GetPreparer, 3)" -> {"(Prepare, 1)";}
"(PullImage, 7)" -> {"(pullImageWithReference, 6)";}
"(Check, 1)" -> {}
"(NewGroup, 3)" -> {"(newServer, 2)";}
"(wait, 1)" -> {}
"(withAggregator, 4)" -> {"(createAggregatorServer, 3)";}
"(BuildHandlerChain, 5)" -> {}
"(attachScale, 4)" -> {"(scaleUp, 5)";}
"(createAggregatorServer, 3)" -> {}
"(newServer, 2)" -> {}
"(RestartNode, 1)" -> {}
"(delete, 2)" -> {"(Remove, 2)";"(Detach, 2)";"(Encode, 1)";"(Delete, 1)";"(runDelete, 6)";"(Delete, 3)";}
"(restartNode, 2)" -> {"(RestartNode, 1)";}
"(AddPod, 1)" -> {"(UpdatePod, 1)";}
"(waitUntilFreshAndBlock, 2)" -> {}
"(New, 9)" -> {"(CopyConsole, 7)";}
"(pull, 4)" -> {}
"(Create, 3)" -> {"(CreateBricks, 3)";"(DestroyBricks, 3)";"(Destroy, 2)";}
"(Open, 2)" -> {"(newArchiveFromGuest, 1)";"(newArchiveToGuest, 1)";"(Dispatch, 3)";"(ServeHTTP, 2)";}
"(handle, 1)" -> {"(Delete, 2)";}
"(NewSession, 2)" -> {}
"(CopyConsole, 7)" -> {}
"(Schedule, 2)" -> {"(PrioritizeNodes, 6)";}
"(NewTCPSocket, 2)" -> {"(NewListener, 2)";}
"(Destroy, 2)" -> {"(checkBricksCanBeDestroyed, 3)";}
"(Interpret, 5)" -> {"(call, 5)";}
"(Load, 1)" -> {"(New, 1)";}
"(NewDaemon, 4)" -> {}
"(addReadinessCheckRoute, 3)" -> {"(Write, 1)";}
"(tlsDialWithDialer, 4)" -> {}
"(Run, 2)" -> {"(Remove, 2)";"(List, 2)";"(Execute, 3)";"(Prepare, 1)";"(Create, 2)";"(Create, 3)";"(Register, 2)";"(Start, 2)";"(Run, 1)";"(Save, 3)";"(Write, 1)";"(StartUpdater, 2)";"(RunSnap, 2)";"(add, 1)";"(List, 1)";"(run, 1)";"(Apply, 3)";"(RunShort, 2)";"(create, 1)";}
"(callRemoteBalancer, 2)" -> {}
"(WaitForRunningDeployment, 3)" -> {"(Watch, 1)";}
"(name, 1)" -> {"(update, 1)";}
"(NewListener, 2)" -> {"(NewTimeoutListener, 5)";}
"(Start, 1)" -> {"(Read, 2)";"(start, 1)";"(start, 2)";"(List, 1)";"(Dial, 3)";"(copyPipes, 7)";"(Start, 2)";"(Run, 1)";"(NewServer, 1)";}
"(parseFiles, 6)" -> {}
"(Index, 2)" -> {"(Execute, 2)";}
"(Upload, 3)" -> {"(update, 1)";}
"(newAuthenticator, 2)" -> {"(SetTransportDefaults, 1)";}
"(clientHandshake, 2)" -> {"(newClientTransport, 6)";}
"(Verifier, 1)" -> {"(newAsyncIDTokenVerifier, 3)";}
"(Init, 1)" -> {"(Init, 4)";"(Put, 2)";"(New, 5)";"(Update, 1)";}
"(ConfigureTransport, 1)" -> {"(configureTransport, 1)";}
"(NewServerTLS, 2)" -> {"(newServer, 2)";"(NewGroup, 3)";}
"(serverHandshake, 1)" -> {"(newServerTransport, 4)";}
"(Prepare, 3)" -> {"(CreateVolume, 1)";}
"(NewServer, 1)" -> {"(NewServerTLS, 2)";"(startNode, 3)";"(restartNode, 2)";"(restartAsStandaloneNode, 2)";"(openBackend, 1)";}
"(Install, 1)" -> {"(Delete, 2)";}
"(Execute, 2)" -> {"(Run, 3)";}
"(CreateBricks, 3)" -> {"(createDestroyConcurrently, 4)";}
"(configureTransport, 1)" -> {"(addConnIfNeeded, 3)";}
"(Watch, 2)" -> {}
"(Append, 3)" -> {"(run, 1)";}
"(startNode, 3)" -> {"(StartNode, 2)";}
"(Copy, 2)" -> {"(Write, 1)";"(From, 1)";"(ServeHTTP, 2)";}
"(TarWithOptions, 2)" -> {}
"(runFrame, 1)" -> {"(visitInstr, 2)";}
"(startControllers, 5)" -> {}
"(StartUpdater, 2)" -> {"(newLeaseUpdater, 3)";}
"(DetailedRoundTrip, 1)" -> {"(getConn, 1)";}
"(Terminate, 1)" -> {}
"(implements, 1)" -> {"(Build, 1)";}
"(parsePackageFiles, 2)" -> {"(parseFiles, 6)";}
"(startThinPoolWatcher, 1)" -> {}
"(newLeaseUpdater, 3)" -> {}
"(Encode, 1)" -> {"(Write, 1)";}
"(Commit, 2)" -> {"(Register, 3)";}
"(checkBricksCanBeDestroyed, 3)" -> {}
"(NewBroker, 3)" -> {}
"(Validate, 1)" -> {"(Validate, 2)";}
"(Build, 0)" -> {"(Build, 1)";}
"(getURL, 1)" -> {"(SetTransportDefaults, 1)";"(RoundTrip, 1)";}
"(Dial, 3)" -> {"(NewClientConn, 3)";}
"(recvtty, 2)" -> {"(ConsoleFromFile, 1)";}
"(create, 2)" -> {"(Snapshot, 3)";}
"(CreateAndInitKubelet, 31)" -> {"(NewMainKubelet, 31)";}
"(newOOMCollector, 1)" -> {}
"(Do, 3)" -> {}
"(Execute, 3)" -> {"(StreamContainerIO, 3)";}
"(Detach, 2)" -> {"(Delete, 2)";"(DetachDisk, 3)";}
"(dial, 3)" -> {"(tlsDial, 3)";}
"(Watch, 3)" -> {"(Watch, 1)";}
"(Snapshot, 3)" -> {"(Snapshot, 2)";}
"(ServeHTTP, 2)" -> {"(tryUpgrade, 2)";"(RemoveMember, 2)";"(serveUpgrade, 2)";"(Check, 1)";"(handleHttps, 2)";"(serveStatus, 2)";}
"(dial, 2)" -> {"(NewServerConn, 2)";"(NewClientConn, 3)";}
"(Prepare, 1)" -> {"(Upgrade, 7)";"(Pull, 8)";"(pullImage, 1)";}
"(RefreshCertificateAfterExpiry, 4)" -> {}
"(addPod, 1)" -> {"(AddPod, 1)";}
"(Open, 1)" -> {"(Open, 2)";"(prepareStatement, 2)";}
"(Prepare, 2)" -> {"(Prepare, 1)";}
"(createDestroyConcurrently, 4)" -> {}
"(pullImageWithReference, 6)" -> {}
"(run, 2)" -> {"(Run, 2)";}
"(snapshotPath, 4)" -> {}
"(Accept, 2)" -> {}
"(List, 2)" -> {}
"(Write, 1)" -> {"(wait, 1)";"(Capture, 2)";"(send, 1)";"(Execute, 2)";}
"(Add, 1)" -> {"(add, 1)";"(watch, 3)";}
"(Dial, 2)" -> {"(dial, 3)";"(Dial, 3)";}
"(index, 1)" -> {"(update, 1)";}
"(getETag, 2)" -> {"(Set, 2)";"(Do, 1)";}
"(Delete, 2)" -> {"(stop, 1)";"(Write, 1)";}
"(Watch, 1)" -> {"(Watch, 2)";}
"(allPackages, 3)" -> {}
"(Upgrade, 7)" -> {"(pull, 4)";}
"(Pull, 8)" -> {"(pull, 4)";}
"(Name, 1)" -> {"(name, 1)";}
"(configureKubeConfigForClientCertRotation, 2)" -> {"(RefreshCertificateAfterExpiry, 4)";}
"(UpdatePod, 2)" -> {"(updatePod, 2)";}
"(newArchiveToGuest, 1)" -> {}
"(start, 2)" -> {}
"(newAsyncIDTokenVerifier, 3)" -> {}
"(newWatchBroadcasts, 1)" -> {}
"(StreamContainerIO, 3)" -> {}
"(awaitOpenSlotForRequest, 1)" -> {}
"(executeExecNewPod, 4)" -> {}
"(Remove, 1)" -> {"(Delete, 2)";"(Close, 1)";"(Search, 2)";"(Detach, 2)";"(index, 1)";"(Remove, 2)";}
"(newArchiveFromGuest, 1)" -> {}
"(Run, 1)" -> {"(NewSSHTunnelList, 4)";"(withAggregator, 4)";"(run, 1)";"(Execute, 2)";"(BuildHandlerChain, 5)";"(StreamContainerIO, 3)";"(CreateControllerContext, 4)";"(create, 2)";"(Register, 2)";"(startControllers, 5)";"(Write, 1)";}
"(scaleUp, 5)" -> {"(run, 4)";}
"(create, 1)" -> {"(Create, 3)";}
"(newTLSListener, 2)" -> {}
"(Delete, 1)" -> {"(Remove, 2)";"(Delete, 2)";}
"(post, 1)" -> {}
"(mount, 2)" -> {"(attachScale, 4)";}
"(NewDynamicResourceConsumer, 12)" -> {"(newResourceConsumer, 18)";}
"(Get, 5)" -> {"(WaitUntilFreshAndGet, 3)";}
"(runDelete, 6)" -> {"(Delete, 2)";}
"(tlsDial, 3)" -> {"(tlsDialWithDialer, 4)";}
"(restartAsStandaloneNode, 2)" -> {"(RestartNode, 1)";}
"(CreateControllerContext, 4)" -> {}
"(Set, 1)" -> {"(add, 1)";}
"(serveUpgrade, 2)" -> {}
"(initInformers, 1)" -> {}
"(Apply, 1)" -> {"(Apply, 3)";}
"(copy, 2)" -> {"(Create, 1)";"(get, 1)";"(Open, 1)";"(Copy, 2)";}
"(getConn, 1)" -> {}
"(Add, 2)" -> {"(add, 1)";"(Validate, 1)";"(index, 1)";}
"(NewClusterV3, 2)" -> {"(Launch, 1)";}
"(handleControlSocketChange, 2)" -> {}
"(updatePod, 2)" -> {"(AddPod, 1)";"(addPod, 1)";}
"(NewMainKubelet, 31)" -> {}
"(run, 4)" -> {"(NewDynamicResourceConsumer, 12)";"(Interpret, 5)";}
"(targetPortForService, 3)" -> {"(Get, 1)";}
"(NewServer, 2)" -> {"(NewServer, 1)";}
"(ListenPipe, 2)" -> {}
"(PrioritizeNodes, 6)" -> {}
"(Register, 3)" -> {"(startThinPoolWatcher, 1)";"(startZfsWatcher, 1)";}
"(openBackend, 1)" -> {}
"(Read, 2)" -> {"(Copy, 4)";}
"(newClientTransport, 6)" -> {}
"(snap, 2)" -> {"(Snapshot, 3)";}
"(Get, 2)" -> {"(Open, 2)";"(Parse, 1)";"(Validate, 1)";"(New, 2)";"(getURL, 1)";"(handle, 1)";"(Stat, 2)";"(Do, 1)";"(Put, 3)";"(Add, 1)";"(get, 1)";"(Name, 1)";"(Do, 2)";"(Accept, 2)";"(New, 1)";"(Set, 2)";"(getServiceAccountTokens, 1)";"(Unmount, 1)";"(implements, 1)";"(Get, 3)";"(Add, 2)";"(Get, 0)";}
"(New, 2)" -> {"(Register, 1)";"(NewServer, 2)";"(Put, 2)";"(Dial, 2)";"(Apply, 1)";"(New, 1)";"(load, 1)";"(NewSession, 2)";"(Start, 1)";"(Init, 1)";"(Update, 1)";"(run, 2)";"(loadPlugins, 1)";"(Add, 1)";"(Unmount, 1)";}
"(New, 1)" -> {"(Verifier, 1)";"(initOAuthAuthorizationServerMetadataRoute, 2)";"(newClient, 1)";"(Run, 2)";"(Remove, 1)";"(Get, 0)";"(get, 1)";"(Update, 1)";"(New, 5)";"(Install, 1)";"(NewBroker, 3)";"(Start, 1)";"(NewClient, 1)";"(Register, 1)";"(Run, 1)";"(addReadinessCheckRoute, 3)";"(newOOMCollector, 1)";"(initDiscovery, 1)";"(Read, 2)";"(newAuthenticator, 2)";}
"(loadPlugins, 1)" -> {"(Register, 1)";"(Init, 1)";}
"(UpdatePod, 1)" -> {}
"(Create, 2)" -> {"(Check, 1)";"(CreateVolume, 1)";"(New, 9)";"(Create, 3)";"(Apply, 3)";"(initInformers, 1)";}
"(Put, 2)" -> {"(Save, 3)";}
"(Snapshot, 2)" -> {}
"(initDiscovery, 1)" -> {"(Watch, 3)";}
"(visitInstr, 2)" -> {}
"(Parse, 1)" -> {"(handle, 1)";"(Build, 0)";"(Set, 2)";"(Add, 1)";}
"(Register, 1)" -> {"(Register, 2)";}
"(copyPipes, 7)" -> {}
"(Apply, 3)" -> {"(Apply, 2)";}
"(callSSA, 6)" -> {"(runFrame, 1)";}
"(Get, 0)" -> {"(Get, 3)";"(Do, 1)";"(Initialize, 1)";"(Get, 5)";"(get, 1)";"(Delete, 1)";}
"(hash, 1)" -> {"(Write, 1)";}
"(Save, 3)" -> {"(snapshotPath, 4)";}
"(schedule, 1)" -> {"(Schedule, 2)";}
"(shutdownDaemon, 1)" -> {}
"(New, 5)" -> {"(configureKubeConfigForClientCertRotation, 2)";}
"(startZfsWatcher, 1)" -> {}
"(Apply, 2)" -> {"(Diff, 3)";}
"(Put, 3)" -> {"(Copy, 2)";"(Put, 2)";"(Create, 1)";"(Commit, 2)";"(Apply, 1)";}
"(getTmpROC, 2)" -> {"(Write, 1)";}
"(serveStatus, 2)" -> {}
"(tryUpgrade, 2)" -> {}
"(FromBytes, 1)" -> {"(Write, 1)";}
"(Diff, 2)" -> {"(TarWithOptions, 2)";}
"(newMaster, 1)" -> {"(setUp, 1)";}
"(get, 1)" -> {"(delete, 2)";"(Do, 1)";"(load, 1)";"(FromBytes, 1)";"(Add, 2)";"(SetTransportDefaults, 1)";"(Read, 2)";"(Upload, 3)";}
"(run, 3)" -> {"(UpdateTransport, 4)";"(RunKubelet, 4)";}
"(updateTransport, 5)" -> {}
"(CreateVolume, 1)" -> {}
"(Create, 1)" -> {"(Update, 1)";"(Create, 2)";"(create, 1)";"(Apply, 1)";}
"(Build, 1)" -> {"(StreamContainerIO, 3)";"(Execute, 3)";"(ForEachPackage, 2)";"(NewKubernetesSource, 1)";"(Prepare, 1)";}
"(Register, 2)" -> {"(addEndpoint, 1)";}
"(Capture, 2)" -> {}
"(add, 1)" -> {"(newWatchBroadcast, 3)";"(newWatchBroadcasts, 1)";"(post, 1)";}
"(pullImage, 1)" -> {"(PullImage, 7)";}
"(List, 1)" -> {"(List, 2)";}
"(initializeAndStartHeartbeat, 4)" -> {}
"(setupIO, 6)" -> {"(recvtty, 2)";"(setupProcessPipes, 3)";}
"(NewClientConn, 3)" -> {"(clientHandshake, 2)";}
"(Update, 1)" -> {"(update, 1)";}
"(start, 1)" -> {"(shutdownDaemon, 1)";"(handleControlSocketChange, 2)";"(CopyConsole, 7)";"(copyPipes, 7)";"(Start, 2)";"(NewDaemon, 4)";}
"(handleHttps, 2)" -> {}
"(apply, 1)" -> {"(Append, 3)";}
"(Execute, 4)" -> {"(executeExecNewPod, 4)";}
"(Remove, 2)" -> {}
"(Unmount, 1)" -> {"(Run, 2)";"(New, 5)";}
"(newResourceConsumer, 18)" -> {}
"(call, 5)" -> {"(callSSA, 6)";}
"(Get, 3)" -> {"(Do, 2)";"(Do, 3)";"(List, 1)";"(WaitForRunningDeployerPod, 3)";"(GetPreparer, 3)";"(Do, 1)";"(Put, 2)";"(Validate, 1)";"(Add, 2)";"(Build, 0)";"(Set, 2)";"(RoundTrip, 1)";"(WaitForRunningDeployment, 3)";"(Get, 5)";"(Apply, 1)";"(Copy, 2)";"(Write, 1)";"(Add, 1)";}
"(initOAuthAuthorizationServerMetadataRoute, 2)" -> {"(Write, 1)";}
"(setupProcessPipes, 3)" -> {}
"(RemoveMember, 2)" -> {"(removeMember, 2)";}
"(ForEachPackage, 2)" -> {"(allPackages, 3)";}
"(RunShort, 2)" -> {"(create, 2)";"(mount, 2)";}
"(RunKubelet, 4)" -> {"(startKubelet, 5)";"(CreateAndInitKubelet, 31)";}
"(NewUnsecuredEtcd3TestClientServer, 1)" -> {"(NewClusterV3, 2)";}
"(newWatchBroadcast, 3)" -> {}
"(addEndpoint, 1)" -> {}
"(prepareStatement, 2)" -> {"(Prepare, 1)";}
"(From, 1)" -> {"(Run, 3)";}
"(Get, 1)" -> {"(Read, 1)";"(getURL, 1)";"(Unmarshal, 2)";"(lookup, 1)";"(Get, 2)";"(Get, 3)";"(hash, 1)";"(fetch, 1)";"(getRange, 1)";"(delete, 2)";"(Remove, 1)";"(get, 2)";"(Set, 2)";"(apply, 1)";"(Parse, 1)";"(Search, 2)";"(Add, 2)";"(Do, 2)";"(Open, 1)";"(getETag, 2)";"(get, 1)";"(getTmpROC, 2)";"(copy, 2)";"(New, 2)";"(New, 1)";"(Put, 1)";"(Load, 1)";"(Get, 0)";"(Set, 1)";"(Add, 1)";}
"(Init, 4)" -> {"(ListenPipe, 2)";"(NewTCPSocket, 2)";}
"(Delete, 3)" -> {"(Delete, 2)";"(run, 1)";}
"(Run, 3)" -> {"(run, 3)";}
"(Copy, 4)" -> {"(Execute, 4)";}
"(NewTimeoutListener, 5)" -> {"(wrapTLS, 4)";}
"(routeMatchesIngress, 6)" -> {"(Get, 1)";"(targetPortForService, 3)";}
"(Stat, 2)" -> {"(Do, 3)";}
"(RoundTrip, 1)" -> {"(awaitOpenSlotForRequest, 1)";"(DetailedRoundTrip, 1)";}
"(getServiceAccountTokens, 1)" -> {"(List, 1)";}
"(NewKubernetesSource, 1)" -> {}
"(run, 1)" -> {"(forward, 3)";"(schedule, 1)";"(setupIO, 6)";}
"(Diff, 3)" -> {"(Diff, 2)";}
"(DestroyBricks, 3)" -> {"(createDestroyConcurrently, 4)";}
"(WaitUntilFreshAndGet, 3)" -> {"(waitUntilFreshAndBlock, 2)";}
"(removeMember, 2)" -> {"(Terminate, 1)";}
"(UpdateTransport, 4)" -> {"(updateTransport, 5)";}
"(ConsoleFromFile, 1)" -> {"(newMaster, 1)";}
"(Read, 1)" -> {"(Update, 3)";"(Do, 1)";"(Read, 2)";"(Limit, 3)";"(Copy, 2)";"(Write, 1)";"(add, 1)";"(Add, 1)";}
"(Search, 2)" -> {"(List, 1)";"(Set, 2)";"(Create, 1)";"(Execute, 2)";}
"(lookup, 1)" -> {"(hash, 1)";"(Search, 2)";}
"(Initialize, 1)" -> {"(Write, 1)";}
}

```

Leave a reaction on this issue to contribute to the project by classifying this instance as a **Bug** :-1:, **Mitigated** :+1:, or **Desirable Behavior** :rocket:
See the descriptions of the classifications [here](https://github.com/github-vet/rangeclosure-findings#how-can-i-help) for more information.

commit ID: 07e45cb8ec631f158f6c7c29330a9cdeae9f4a29