remove abstract resource node from destroy node

NodeDestroyResource does not require a provider, and to avoid this a
temporary GraphNodeNoProvider was used to differentiate it from other
resource nodes. We can now de-couple the destroy node from the abstract
resource which was adding the ProvidedBy method, and remove the
NoProvider method.

terraform/graph_builder_apply.go

@@ -74,12 +74,6 @@ func (b *ApplyGraphBuilder) Steps() []GraphTransformer {
 		}
 	}
 
-	concreteOrphanResource := func(a *NodeAbstractResource) dag.Vertex {
-		return &NodeDestroyResource{
-			NodeAbstractResource: a,
-		}
-	}
-
 	concreteResourceInstance := func(a *NodeAbstractResourceInstance) dag.Vertex {
 		return &NodeApplyableResourceInstance{
 			NodeAbstractResourceInstance: a,
@@ -113,9 +107,8 @@ func (b *ApplyGraphBuilder) Steps() []GraphTransformer {
 		// it's just cleanup of our own state object, and so doesn't effect
 		// any real remote objects or consumable outputs.)
 		&OrphanResourceTransformer{
-			Concrete: concreteOrphanResource,
+			Config: b.Config,
-			Config:   b.Config,
+			State:  b.State,
-			State:    b.State,
 		},
 
 		// Create orphan output nodes

terraform/node_resource_apply.go

@@ -71,8 +71,7 @@ func (n *nodeExpandApplyableResource) DynamicExpand(ctx EvalContext) (*Graph, er
 	for _, res := range orphans {
 		// add the resource cleanup node to remove the resource from state
 		cleanupNode := &NodeDestroyResource{
-			NodeAbstractResource: NewNodeAbstractResource(res.Addr.Config()),
+			Addr: res.Addr,
-			Addr:                 res.Addr,
 		}
 
 		g.Add(cleanupNode)

terraform/node_resource_destroy.go

@@ -288,7 +288,6 @@ func (n *NodeDestroyResourceInstance) EvalTree() EvalNode {
 // leaving skeleton resource objects in state after their instances have
 // all been destroyed.
 type NodeDestroyResource struct {
-	*NodeAbstractResource
 	Addr addrs.AbsResource
 }
 
@@ -298,21 +297,18 @@ var (
 	_ GraphNodeReferenceable  = (*NodeDestroyResource)(nil)
 	_ GraphNodeReferencer     = (*NodeDestroyResource)(nil)
 	_ GraphNodeEvalable       = (*NodeDestroyResource)(nil)
-
-	// FIXME: this is here to document that this node is both
-	// GraphNodeProviderConsumer by virtue of the embedded
-	// NodeAbstractResource, but that behavior is not desired and we skip it by
-	// checking for GraphNodeNoProvider.
-	_ GraphNodeProviderConsumer = (*NodeDestroyResource)(nil)
-	_ GraphNodeNoProvider       = (*NodeDestroyResource)(nil)
 )
 
 func (n *NodeDestroyResource) Path() addrs.ModuleInstance {
 	return n.Addr.Module
 }
 
+func (n *NodeDestroyResource) ModulePath() addrs.Module {
+	return n.Addr.Module.Module()
+}
+
 func (n *NodeDestroyResource) Name() string {
-	return n.ResourceAddr().String() + " (clean up state)"
+	return n.Addr.String() + " (clean up state)"
 }
 
 // GraphNodeReferenceable, overriding NodeAbstractResource
@@ -340,21 +336,11 @@ func (n *NodeDestroyResource) EvalTree() EvalNode {
 	// leftover husk of a resource in state after all of the child instances
 	// and their objects were destroyed.
 	return &EvalForgetResourceState{
-		Addr: n.ResourceAddr().Resource,
+		Addr: n.Addr.Resource,
 	}
 }
 
 // GraphNodeResource
 func (n *NodeDestroyResource) ResourceAddr() addrs.ConfigResource {
-	return n.NodeAbstractResource.ResourceAddr()
+	return n.Addr.Config()
-}
-
-// GraphNodeNoProvider
-// FIXME: this should be removed once the node can be separated from the
-// Internal NodeAbstractResource behavior.
-func (n *NodeDestroyResource) NoProvider() {
-}
-
-type GraphNodeNoProvider interface {
-	NoProvider()
 }

terraform/transform_orphan_resource.go

@@ -159,15 +159,13 @@ func (t *OrphanResourceTransformer) Transform(g *Graph) error {
 				}
 			}
 
-			addr := rs.Addr
+			node := &NodeDestroyResource{
-			abstract := NewNodeAbstractResource(addr.Config())
+				Addr: rs.Addr,
-			var node dag.Vertex = abstract
-			if f := t.Concrete; f != nil {
-				node = f(abstract)
 			}
-			log.Printf("[TRACE] OrphanResourceTransformer: adding whole-resource orphan node for %s", addr)
+
+			log.Printf("[TRACE] OrphanResourceTransformer: adding whole-resource orphan node for %s", rs.Addr)
 			g.Add(node)
-			for _, dn := range deps[addr.String()] {
+			for _, dn := range deps[rs.Addr.String()] {
 				log.Printf("[TRACE] OrphanResourceTransformer: node %q depends on %q", dag.VertexName(node), dag.VertexName(dn))
 				g.Connect(dag.BasicEdge(node, dn))
 			}

terraform/transform_provider.go

@@ -109,14 +109,6 @@ func (t *ProviderTransformer) Transform(g *Graph) error {
 	requested := map[dag.Vertex]map[string]ProviderRequest{}
 	needConfigured := map[string]addrs.AbsProviderConfig{}
 	for _, v := range g.Vertices() {
-
-		// FIXME: fix the type that implements this, so it's not a
-		// GraphNodeProviderConsumer.
-		// check if we want to skip connecting this to a provider
-		if _, ok := v.(GraphNodeNoProvider); ok {
-			continue
-		}
-
 		// Does the vertex _directly_ use a provider?
 		if pv, ok := v.(GraphNodeProviderConsumer); ok {
 			requested[v] = make(map[string]ProviderRequest)
@@ -325,13 +317,6 @@ func (t *MissingProviderTransformer) Transform(g *Graph) error {
 	var err error
 	m := providerVertexMap(g)
 	for _, v := range g.Vertices() {
-		// FIXME: fix the type that implements this, so it's not a
-		// GraphNodeProviderConsumer.
-		// check if we want to skip connecting this to a provider
-		if _, ok := v.(GraphNodeNoProvider); ok {
-			continue
-		}
-
 		pv, ok := v.(GraphNodeProviderConsumer)
 		if !ok {
 			continue