Remove defer Statement

[gsquire]

This small patch removes a defer statement inside of a for loop and calls Close after the scanner is done reading the file.

[muesli]

Thanks for PR, @gsquire! I'm not sure however if this is fixing or improving anything. Can you elaborate?

Edit: I guess it would make a difference if you got a larger amount of dictionaries and want to prevent keeping the file handles open. Makes sense.

[muesli]

Thank you!

[gsquire]

You're welcome! My reasoning was that the defer calls will stack up and not reference the correct open file when they are finally invoked. Thus you would leak open files.

[muesli]

Hah, I see you've even written your own little detector: https://github.com/gsquire/dll

Kudos, nice work!

[gsquire]

Thanks, hope you can find it useful :)

[muesli]

Note: I don't think that would have been an issue here, as file is declared in the scope of the for loop.

Also, unless I'm entirely mistaken, this should also only be a problem if the actual loop-value were to be evaluated in the deferred call.

For example, this isn't a problem:

package main

import "fmt"

type foo struct {
	name string
}

func (f foo) print() {
	fmt.Println(f.name)
}

func main() {
	var f []foo

	f = append(f, foo{name: "a"})
	f = append(f, foo{name: "b"})
	f = append(f, foo{name: "c"})

	for _, v := range f {
		defer v.print()
	}
}

Output (as expected):

c
b
a

This however would lead to problems:

package main

import "fmt"

type foo struct {
	name string
}

func (f foo) print() {
	fmt.Println(f.name)
}

func main() {
	var f []foo

	f = append(f, foo{name: "a"})
	f = append(f, foo{name: "b"})
	f = append(f, foo{name: "c"})

	for _, v := range f {
		defer func() {
			v.print()
		}()
	}
}

Output:

c
c
c

Maybe that's something to take into account for dll.

[gsquire]

Yeah, I think the idea is that they could pile up in something like a server with an infinite loop for example. It'd be hard to check that semantically within the tool but it's something cool to explore. There is a way around it as well.