tftypes: Added AttributePath LastStep method and AttributePathStep Equal method

.changelog/112.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+tftypes: Added `AttributePath` `LastStep()` method and `AttributePathStep` `Equal()` method
+```

tftypes/attribute_path.go

@@ -85,21 +85,9 @@ func (a *AttributePath) Equal(o *AttributePath) bool {
 	}
 	for pos, aStep := range a.Steps() {
 		oStep := o.Steps()[pos]
-		switch aStep.(type) {
-		case AttributeName, ElementKeyString, ElementKeyInt:
-			if oStep != aStep {
-				return false
-			}
-		case ElementKeyValue:
-			oVal, ok := oStep.(ElementKeyValue)
-			if !ok {
-				return false
-			}
-			if !Value(aStep.(ElementKeyValue)).Equal(Value(oVal)) {
-				return false
-			}
-		default:
-			panic(fmt.Sprintf("unknown step %T in AttributePath.Equal", aStep))
+
+		if !aStep.Equal(oStep) {
+			return false
 		}
 	}
 	return true
@@ -129,6 +117,18 @@ func (a *AttributePath) NewError(err error) error {
 	}
 }
 
+// LastStep returns the last step in the path. If the path was
+// empty, nil is returned.
+func (a *AttributePath) LastStep() AttributePathStep {
+	steps := a.Steps()
+
+	if len(steps) == 0 {
+		return nil
+	}
+
+	return steps[len(steps)-1]
+}
+
 // WithAttributeName adds an AttributeName step to `a`, using `name` as the
 // attribute's name. `a` is copied, not modified.
 func (a *AttributePath) WithAttributeName(name string) *AttributePath {
@@ -185,6 +185,9 @@ func (a *AttributePath) WithoutLastStep() *AttributePath {
 // indicating a specific attribute or element that is the next value in the
 // path.
 type AttributePathStep interface {
+	// Equal returns true if the AttributePathStep is equal to the other.
+	Equal(AttributePathStep) bool
+
 	unfulfillable() // make this interface fillable only by this package
 }
 
@@ -199,20 +202,56 @@ var (
 // AttributeName is the name of the attribute to be selected.
 type AttributeName string
 
+// Equal returns true if the other AttributePathStep is an AttributeName and
+// has the same value.
+func (a AttributeName) Equal(other AttributePathStep) bool {
+	otherA, ok := other.(AttributeName)
+
+	if !ok {
+		return false
+	}
+
+	return string(a) == string(otherA)
+}
+
 func (a AttributeName) unfulfillable() {}
 
 // ElementKeyString is an AttributePathStep implementation that indicates the
 // next step in the AttributePath is to select an element using a string key.
 // The value of the ElementKeyString is the key of the element to select.
 type ElementKeyString string
 
+// Equal returns true if the other AttributePathStep is an ElementKeyString and
+// has the same value.
+func (e ElementKeyString) Equal(other AttributePathStep) bool {
+	otherE, ok := other.(ElementKeyString)
+
+	if !ok {
+		return false
+	}
+
+	return string(e) == string(otherE)
+}
+
 func (e ElementKeyString) unfulfillable() {}
 
 // ElementKeyInt is an AttributePathStep implementation that indicates the next
 // step in the AttributePath is to select an element using an int64 key. The
 // value of the ElementKeyInt is the key of the element to select.
 type ElementKeyInt int64
 
+// Equal returns true if the other AttributePathStep is an ElementKeyInt and
+// has the same value.
+func (e ElementKeyInt) Equal(other AttributePathStep) bool {
+	otherE, ok := other.(ElementKeyInt)
+
+	if !ok {
+		return false
+	}
+
+	return int(e) == int(otherE)
+}
+
 func (e ElementKeyInt) unfulfillable() {}
 
 // ElementKeyValue is an AttributePathStep implementation that indicates the
@@ -221,6 +260,18 @@ func (e ElementKeyInt) unfulfillable() {}
 // to select.
 type ElementKeyValue Value
 
+// Equal returns true if the other AttributePathStep is an ElementKeyValue and
+// has the same value.
+func (e ElementKeyValue) Equal(other AttributePathStep) bool {
+	otherE, ok := other.(ElementKeyValue)
+
+	if !ok {
+		return false
+	}
+
+	return Value(e).Equal(Value(otherE))
+}
+
 func (e ElementKeyValue) unfulfillable() {}
 
 // AttributePathStepper is an interface that types can implement to make them