Remove reference used in loops

.golangci.yml

@@ -0,0 +1,9 @@
+linters:
+  enable:
+    - exportloopref
+    - scopelint
+issues:
+  exclude-rules:
+    - path: _test\.go
+      linters:
+        - scopelint

pkg/remote/aws/ec2_eip_association_supplier.go

@@ -39,6 +39,7 @@ func (s EC2EipAssociationSupplier) Resources() ([]resource.Resource, error) {
 	results := make([]cty.Value, 0)
 	if len(associationIds) > 0 {
 		for _, assocId := range associationIds {
+			assocId := assocId
 			s.runner.Run(func() (cty.Value, error) {
 				return s.readEIPAssociation(assocId)
 			})

pkg/remote/aws/iam_role_policy_supplier.go

@@ -75,12 +75,14 @@ func listIamRolePolicies(client iamiface.IAMAPI, supplierType string) ([]string,
 
 	var resources []string
 	for _, role := range roles {
+		role := role
 		input := &iam.ListRolePoliciesInput{
 			RoleName: role.RoleName,
 		}
 
 		err := client.ListRolePoliciesPages(input, func(res *iam.ListRolePoliciesOutput, lastPage bool) bool {
 			for _, policy := range res.PolicyNames {
+				policy := policy
 				resources = append(
 					resources,
 					fmt.Sprintf(

pkg/remote/aws/vpc_security_group_rule_supplier.go

@@ -167,6 +167,7 @@ func (s VPCSecurityGroupRuleSupplier) addSecurityGroupRule(ruleType string, rule
 	if sg.GroupName != nil && *sg.GroupName == "default" {
 		results := make([]resourceaws.AwsSecurityGroupRule, 0, len(rules))
 		for _, r := range rules {
+			r := r
 			if s.isDefaultIngress(&r) || s.isDefaultEgress(&r) {
 				continue
 			}

pkg/resource/aws/deserializer/db_instance_deserializer.go

@@ -23,6 +23,7 @@ func (s DBInstanceDeserializer) HandledType() resource.ResourceType {
 func (s DBInstanceDeserializer) Deserialize(rawResourceList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, raw := range rawResourceList {
+		raw := raw
 		res, err := decodeDBInstance(&raw)
 		if err != nil {
 			logrus.Warnf("error when deserializing aws_db_instance %+v : %+v", raw, err)

pkg/resource/aws/deserializer/db_subnet_group_deserializer.go

@@ -24,6 +24,7 @@ func (s *DBSubnetGroupDeserializer) HandledType() resource.ResourceType {
 func (s DBSubnetGroupDeserializer) Deserialize(recordList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range recordList {
+		rawResource := rawResource
 		resource, err := decodeDBSubnetGroup(&rawResource)
 		if err != nil {
 			logrus.Warnf("Error when deserializing resource %+v : %+v", rawResource, err)

pkg/resource/aws/deserializer/default_route_table_deserializer.go

@@ -22,6 +22,7 @@ func (s *DefaultRouteTableDeserializer) HandledType() resource.ResourceType {
 func (s DefaultRouteTableDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeDefaultRouteTable(&rawResource)
 		if err != nil {
 			logrus.WithFields(logrus.Fields{

pkg/resource/aws/deserializer/default_security_group_deserializer.go

@@ -24,6 +24,7 @@ func (s *DefaultSecurityGroupDeserializer) HandledType() resource.ResourceType {
 func (s DefaultSecurityGroupDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeDefaultSecurityGroup(&rawResource)
 		if err != nil {
 			logrus.Warnf("Error when deserializing resource %+v : %+v", rawResource, err)

pkg/resource/aws/deserializer/default_subnet_deserializer.go

@@ -24,6 +24,7 @@ func (s *DefaultSubnetDeserializer) HandledType() resource.ResourceType {
 func (s DefaultSubnetDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeDefaultSubnet(&rawResource)
 		if err != nil {
 			logrus.Warnf("Error when deserializing resource %+v : %+v", rawResource, err)

pkg/resource/aws/deserializer/default_vpc_deserializer.go

@@ -24,6 +24,7 @@ func (s *DefaultVPCDeserializer) HandledType() resource.ResourceType {
 func (s DefaultVPCDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeDefaultVPC(&rawResource)
 		if err != nil {
 			logrus.Warnf("Error when deserializing resource %+v : %+v", rawResource, err)

pkg/resource/aws/deserializer/internet_gateway_deserializer.go

@@ -22,6 +22,7 @@ func (s *InternetGatewayDeserializer) HandledType() resource.ResourceType {
 func (s InternetGatewayDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeInternetGateway(&rawResource)
 		if err != nil {
 			logrus.WithFields(logrus.Fields{

pkg/resource/aws/deserializer/nat_gateway_deserializer.go

@@ -22,6 +22,7 @@ func (s *NatGatewayDeserializer) HandledType() resource.ResourceType {
 func (s NatGatewayDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeNatGateway(&rawResource)
 		if err != nil {
 			logrus.WithFields(logrus.Fields{

pkg/resource/aws/deserializer/route53_record_deserializer.go

@@ -24,6 +24,7 @@ func (s Route53RecordDeserializer) HandledType() resource.ResourceType {
 func (s Route53RecordDeserializer) Deserialize(recordList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range recordList {
+		rawResource := rawResource
 		res, err := decodeRoute53Record(&rawResource)
 		if err != nil {
 			logrus.Warnf("Error when deserializing resource %+v : %+v", rawResource, err)

pkg/resource/aws/deserializer/route53_zone_deserializer.go

@@ -24,6 +24,7 @@ func (s Route53ZoneDeserializer) HandledType() resource.ResourceType {
 func (s Route53ZoneDeserializer) Deserialize(zoneList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawZone := range zoneList {
+		rawZone := rawZone
 		zone, err := decodeRoute53Zone(&rawZone)
 		if err != nil {
 			logrus.Warnf("error when reading zone %+v : %+v", rawZone, err)

pkg/resource/aws/deserializer/route_deserializer.go

@@ -22,6 +22,7 @@ func (s *RouteDeserializer) HandledType() resource.ResourceType {
 func (s RouteDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeRoute(&rawResource)
 		if err != nil {
 			logrus.WithFields(logrus.Fields{

pkg/resource/aws/deserializer/route_table_association_deserializer.go

@@ -22,6 +22,7 @@ func (s *RouteTableAssociationDeserializer) HandledType() resource.ResourceType
 func (s RouteTableAssociationDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeRouteTableAssociation(&rawResource)
 		if err != nil {
 			logrus.WithFields(logrus.Fields{

pkg/resource/aws/deserializer/route_table_deserializer.go

@@ -22,6 +22,7 @@ func (s *RouteTableDeserializer) HandledType() resource.ResourceType {
 func (s RouteTableDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeRouteTable(&rawResource)
 		if err != nil {
 			logrus.WithFields(logrus.Fields{

pkg/resource/aws/deserializer/sqs_queue_deserializer.go

@@ -22,6 +22,7 @@ func (s *SqsQueueDeserializer) HandledType() resource.ResourceType {
 func (s SqsQueueDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeSqsQueue(&rawResource)
 		if err != nil {
 			logrus.WithFields(logrus.Fields{

pkg/resource/aws/deserializer/sqs_queue_policy_deserializer.go

@@ -22,6 +22,7 @@ func (s *SqsQueuePolicyDeserializer) HandledType() resource.ResourceType {
 func (s SqsQueuePolicyDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeSqsQueuePolicy(&rawResource)
 		if err != nil {
 			logrus.WithFields(logrus.Fields{

pkg/resource/aws/deserializer/subnet_deserializer.go

@@ -24,6 +24,7 @@ func (s *SubnetDeserializer) HandledType() resource.ResourceType {
 func (s SubnetDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeSubnet(&rawResource)
 		if err != nil {
 			logrus.Warnf("Error when deserializing resource %+v : %+v", rawResource, err)

pkg/resource/aws/deserializer/vpc_deserializer.go

@@ -24,6 +24,7 @@ func (s *VPCDeserializer) HandledType() resource.ResourceType {
 func (s VPCDeserializer) Deserialize(rawList []cty.Value) ([]resource.Resource, error) {
 	resources := make([]resource.Resource, 0)
 	for _, rawResource := range rawList {
+		rawResource := rawResource
 		resource, err := decodeVPC(&rawResource)
 		if err != nil {
 			logrus.Warnf("Error when deserializing resource %+v : %+v", rawResource, err)