plans: Include backend settings in plan and plan files

On the first pass here we erroneously assumed that this was redundant with
the backend settings embedded in the configuration itself. In practice,
users can override backend configuration when running "terraform init"
and so we need to record the _effective_ backend configuration.

Along with this, we also return the selected workspace name at the time
the plan was created so we'll later be able to produce a specialized error
for the situation of having the wrong workspace selected. This isn't
strictly required because we'll also check the lineage of the state, but
the error message that would result from that failure would be relatively
opaque and thus less helpful to the user.

plans/internal/planproto/planfile.pb.go

@@ -52,7 +52,7 @@ func (x Action) String() string {
 	return proto.EnumName(Action_name, int32(x))
 }
 func (Action) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{0}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{0}
 }
 
 type ResourceInstanceChange_ResourceMode int32
@@ -75,7 +75,7 @@ func (x ResourceInstanceChange_ResourceMode) String() string {
 	return proto.EnumName(ResourceInstanceChange_ResourceMode_name, int32(x))
 }
 func (ResourceInstanceChange_ResourceMode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{2, 0}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{3, 0}
 }
 
 // Plan is the root message type for the tfplan file
@@ -105,17 +105,20 @@ type Plan struct {
 	TerraformVersion string `protobuf:"bytes,14,opt,name=terraform_version,json=terraformVersion,proto3" json:"terraform_version,omitempty"`
 	// SHA256 digests of all of the provider plugin binaries that were used
 	// in the creation of this plan.
-	ProviderHashes       map[string]*Hash `protobuf:"bytes,15,rep,name=provider_hashes,json=providerHashes,proto3" json:"provider_hashes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	ProviderHashes map[string]*Hash `protobuf:"bytes,15,rep,name=provider_hashes,json=providerHashes,proto3" json:"provider_hashes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	// Backend is a description of the backend configuration and other related
-	XXX_unrecognized     []byte           `json:"-"`
+	// settings at the time the plan was created.
-	XXX_sizecache        int32            `json:"-"`
+	Backend              *Backend `protobuf:"bytes,13,opt,name=backend,proto3" json:"backend,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *Plan) Reset()         { *m = Plan{} }
 func (m *Plan) String() string { return proto.CompactTextString(m) }
 func (*Plan) ProtoMessage()    {}
 func (*Plan) Descriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{0}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{0}
 }
 func (m *Plan) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Plan.Unmarshal(m, b)
@@ -177,6 +180,68 @@ func (m *Plan) GetProviderHashes() map[string]*Hash {
 	return nil
 }
 
+func (m *Plan) GetBackend() *Backend {
+	if m != nil {
+		return m.Backend
+	}
+	return nil
+}
+
+// Backend is a description of backend configuration and other related settings.
+type Backend struct {
+	Type                 string        `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
+	Config               *DynamicValue `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
+	Workspace            string        `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *Backend) Reset()         { *m = Backend{} }
+func (m *Backend) String() string { return proto.CompactTextString(m) }
+func (*Backend) ProtoMessage()    {}
+func (*Backend) Descriptor() ([]byte, []int) {
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{1}
+}
+func (m *Backend) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Backend.Unmarshal(m, b)
+}
+func (m *Backend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Backend.Marshal(b, m, deterministic)
+}
+func (dst *Backend) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Backend.Merge(dst, src)
+}
+func (m *Backend) XXX_Size() int {
+	return xxx_messageInfo_Backend.Size(m)
+}
+func (m *Backend) XXX_DiscardUnknown() {
+	xxx_messageInfo_Backend.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Backend proto.InternalMessageInfo
+
+func (m *Backend) GetType() string {
+	if m != nil {
+		return m.Type
+	}
+	return ""
+}
+
+func (m *Backend) GetConfig() *DynamicValue {
+	if m != nil {
+		return m.Config
+	}
+	return nil
+}
+
+func (m *Backend) GetWorkspace() string {
+	if m != nil {
+		return m.Workspace
+	}
+	return ""
+}
+
 // Change represents a change made to some object, transforming it from an old
 // state to a new state.
 type Change struct {
@@ -202,7 +267,7 @@ func (m *Change) Reset()         { *m = Change{} }
 func (m *Change) String() string { return proto.CompactTextString(m) }
 func (*Change) ProtoMessage()    {}
 func (*Change) Descriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{1}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{2}
 }
 func (m *Change) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Change.Unmarshal(m, b)
@@ -288,7 +353,7 @@ func (m *ResourceInstanceChange) Reset()         { *m = ResourceInstanceChange{}
 func (m *ResourceInstanceChange) String() string { return proto.CompactTextString(m) }
 func (*ResourceInstanceChange) ProtoMessage()    {}
 func (*ResourceInstanceChange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{2}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{3}
 }
 func (m *ResourceInstanceChange) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResourceInstanceChange.Unmarshal(m, b)
@@ -490,7 +555,7 @@ func (m *OutputChange) Reset()         { *m = OutputChange{} }
 func (m *OutputChange) String() string { return proto.CompactTextString(m) }
 func (*OutputChange) ProtoMessage()    {}
 func (*OutputChange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{3}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{4}
 }
 func (m *OutputChange) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OutputChange.Unmarshal(m, b)
@@ -554,7 +619,7 @@ func (m *DynamicValue) Reset()         { *m = DynamicValue{} }
 func (m *DynamicValue) String() string { return proto.CompactTextString(m) }
 func (*DynamicValue) ProtoMessage()    {}
 func (*DynamicValue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{4}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{5}
 }
 func (m *DynamicValue) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DynamicValue.Unmarshal(m, b)
@@ -600,7 +665,7 @@ func (m *Hash) Reset()         { *m = Hash{} }
 func (m *Hash) String() string { return proto.CompactTextString(m) }
 func (*Hash) ProtoMessage()    {}
 func (*Hash) Descriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{5}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{6}
 }
 func (m *Hash) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Hash.Unmarshal(m, b)
@@ -641,7 +706,7 @@ func (m *Path) Reset()         { *m = Path{} }
 func (m *Path) String() string { return proto.CompactTextString(m) }
 func (*Path) ProtoMessage()    {}
 func (*Path) Descriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{6}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{7}
 }
 func (m *Path) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Path.Unmarshal(m, b)
@@ -682,7 +747,7 @@ func (m *Path_Step) Reset()         { *m = Path_Step{} }
 func (m *Path_Step) String() string { return proto.CompactTextString(m) }
 func (*Path_Step) ProtoMessage()    {}
 func (*Path_Step) Descriptor() ([]byte, []int) {
-	return fileDescriptor_planfile_8d966014b6720da2, []int{6, 0}
+	return fileDescriptor_planfile_f722ed393ded62c3, []int{7, 0}
 }
 func (m *Path_Step) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Path_Step.Unmarshal(m, b)
@@ -811,6 +876,7 @@ func init() {
 	proto.RegisterType((*Plan)(nil), "tfplan.Plan")
 	proto.RegisterMapType((map[string]*Hash)(nil), "tfplan.Plan.ProviderHashesEntry")
 	proto.RegisterMapType((map[string]*DynamicValue)(nil), "tfplan.Plan.VariablesEntry")
+	proto.RegisterType((*Backend)(nil), "tfplan.Backend")
 	proto.RegisterType((*Change)(nil), "tfplan.Change")
 	proto.RegisterType((*ResourceInstanceChange)(nil), "tfplan.ResourceInstanceChange")
 	proto.RegisterType((*OutputChange)(nil), "tfplan.OutputChange")
@@ -822,59 +888,62 @@ func init() {
 	proto.RegisterEnum("tfplan.ResourceInstanceChange_ResourceMode", ResourceInstanceChange_ResourceMode_name, ResourceInstanceChange_ResourceMode_value)
 }
 
-func init() { proto.RegisterFile("planfile.proto", fileDescriptor_planfile_8d966014b6720da2) }
+func init() { proto.RegisterFile("planfile.proto", fileDescriptor_planfile_f722ed393ded62c3) }
 
-var fileDescriptor_planfile_8d966014b6720da2 = []byte{
+var fileDescriptor_planfile_f722ed393ded62c3 = []byte{
-	// 804 bytes of a gzipped FileDescriptorProto
+	// 862 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x55, 0xdb, 0x6e, 0xe3, 0x36,
-	0x10, 0xb5, 0x6c, 0x45, 0xb1, 0xc7, 0x5e, 0x45, 0xcb, 0x16, 0x0b, 0x21, 0x2d, 0xb6, 0x86, 0x80,
+	0x10, 0x8d, 0x6c, 0xc5, 0x97, 0xb1, 0xa3, 0x68, 0xd9, 0x62, 0x21, 0xa4, 0x8b, 0xad, 0x21, 0xa0,
-	0x76, 0x8d, 0xdd, 0xc2, 0x01, 0x52, 0xb4, 0xe9, 0xb6, 0x0f, 0x45, 0x2e, 0x02, 0x12, 0xec, 0x25,
+	0x5d, 0x77, 0xb7, 0x70, 0x00, 0x17, 0x6d, 0xba, 0xed, 0x43, 0x91, 0x8b, 0x81, 0x04, 0x7b, 0x89,
-	0x06, 0xbb, 0xcd, 0x43, 0x1f, 0x6a, 0x30, 0xd2, 0x24, 0x26, 0x56, 0xa2, 0x54, 0x92, 0x36, 0xe0,
+	0xc1, 0x6e, 0xf3, 0xd0, 0x87, 0x1a, 0xb4, 0x34, 0xb1, 0x89, 0x48, 0x94, 0x4a, 0xd2, 0x2e, 0xfc,
-	0xb7, 0xfe, 0x4c, 0xbf, 0xa7, 0xbf, 0x54, 0x90, 0xba, 0x44, 0x01, 0x02, 0x3f, 0x59, 0x73, 0xe6,
+	0x41, 0x7d, 0xea, 0xc7, 0xf4, 0x97, 0x0a, 0x52, 0x17, 0x3b, 0x40, 0xea, 0x27, 0x6b, 0xce, 0x0c,
-	0xcc, 0x88, 0xe7, 0xcc, 0x50, 0x06, 0xbf, 0xcc, 0x98, 0xb8, 0xe3, 0x19, 0xce, 0x4b, 0x59, 0xe8,
+	0x0f, 0x67, 0xce, 0xcc, 0xd0, 0xe0, 0xe5, 0x09, 0x13, 0xf7, 0x3c, 0xc1, 0x51, 0x2e, 0x33, 0x9d,
-	0x82, 0x78, 0xfa, 0xce, 0x20, 0xd1, 0x3f, 0x2e, 0xb8, 0x8b, 0x8c, 0x09, 0x12, 0xc2, 0xfe, 0x06,
+	0x91, 0x96, 0xbe, 0x37, 0x48, 0xf8, 0x8f, 0x0b, 0xee, 0x34, 0x61, 0x82, 0x04, 0xd0, 0x5e, 0xa3,
-	0xa5, 0xe2, 0x85, 0x08, 0x9d, 0xa9, 0x33, 0x73, 0x69, 0x13, 0x92, 0xb7, 0x30, 0xda, 0x30, 0xc9,
+	0x54, 0x3c, 0x13, 0x81, 0x33, 0x70, 0x86, 0x2e, 0xad, 0x4c, 0xf2, 0x16, 0xba, 0x6b, 0x26, 0x39,
-	0xd9, 0x6d, 0x86, 0x2a, 0xec, 0x4f, 0x07, 0xb3, 0xf1, 0xf1, 0x57, 0xf3, 0xaa, 0x7c, 0x6e, 0x4a,
+	0x9b, 0x27, 0xa8, 0x82, 0xc6, 0xa0, 0x39, 0xec, 0x8d, 0xbf, 0x18, 0x15, 0xc7, 0x47, 0xe6, 0xe8,
-	0xe7, 0x37, 0x4d, 0x36, 0x16, 0x5a, 0x6e, 0xe9, 0x03, 0x9b, 0x5c, 0x41, 0x20, 0x51, 0x15, 0x6b,
+	0xe8, 0xae, 0xf2, 0x4e, 0x84, 0x96, 0x1b, 0xba, 0x8d, 0x26, 0x37, 0xe0, 0x4b, 0x54, 0xd9, 0x4a,
-	0x99, 0xe0, 0x32, 0x59, 0x31, 0x71, 0x8f, 0x2a, 0x1c, 0xd8, 0x0e, 0x2f, 0x9b, 0x0e, 0xb4, 0xce,
+	0x46, 0x38, 0x8b, 0x96, 0x4c, 0x2c, 0x50, 0x05, 0x4d, 0xcb, 0xf0, 0xb2, 0x62, 0xa0, 0xa5, 0xff,
-	0x5f, 0x09, 0xa5, 0x99, 0x48, 0xf0, 0xdc, 0xd2, 0xe8, 0x41, 0x53, 0x57, 0xc5, 0x8a, 0xfc, 0x0a,
+	0x46, 0x28, 0xcd, 0x44, 0x84, 0x97, 0x36, 0x8c, 0x1e, 0x57, 0xe7, 0x0a, 0x5b, 0x91, 0x9f, 0xc1,
-	0x7e, 0xb1, 0xd6, 0xe5, 0x5a, 0xb7, 0x8d, 0x5c, 0xdb, 0xe8, 0xcb, 0xa6, 0xd1, 0xb5, 0xcd, 0xd6,
+	0xcb, 0x56, 0x3a, 0x5f, 0xe9, 0x9a, 0xc8, 0xb5, 0x44, 0x9f, 0x57, 0x44, 0xb7, 0xd6, 0x5b, 0x1e,
-	0xe5, 0xcf, 0x8a, 0x4e, 0xa4, 0xc8, 0x1b, 0x78, 0xae, 0x51, 0x4a, 0x76, 0x57, 0xc8, 0x7c, 0xd9,
+	0x3f, 0xca, 0x76, 0x2c, 0x45, 0xde, 0xc0, 0x33, 0x8d, 0x52, 0xb2, 0xfb, 0x4c, 0xa6, 0xb3, 0xaa,
-	0xc8, 0xf4, 0xa7, 0xce, 0x6c, 0x44, 0x83, 0x36, 0x71, 0x53, 0xeb, 0xbd, 0x82, 0x83, 0x52, 0x16,
+	0x4c, 0x6f, 0xe0, 0x0c, 0xbb, 0xd4, 0xaf, 0x1d, 0x77, 0x65, 0xbd, 0x37, 0x70, 0x9c, 0xcb, 0x6c,
-	0x1b, 0x9e, 0xa2, 0x5c, 0xae, 0x98, 0x5a, 0xa1, 0x0a, 0x0f, 0xec, 0xab, 0xa6, 0x8f, 0x54, 0x2f,
+	0xcd, 0x63, 0x94, 0xb3, 0x25, 0x53, 0x4b, 0x54, 0xc1, 0xb1, 0xbd, 0x6a, 0xf0, 0xa8, 0xea, 0x69,
-	0x6a, 0xce, 0xa5, 0xa5, 0x54, 0xd2, 0xfd, 0xf2, 0x11, 0x78, 0x48, 0xc1, 0x7f, 0x6c, 0x0e, 0x09,
+	0x19, 0x73, 0x6d, 0x43, 0x8a, 0xd2, 0xbd, 0xfc, 0x11, 0x48, 0xbe, 0x81, 0xf6, 0x9c, 0x45, 0x0f,
-	0x60, 0xf0, 0x19, 0xb7, 0xd6, 0xe2, 0x11, 0x35, 0x8f, 0xe4, 0x35, 0xec, 0x6d, 0x58, 0xb6, 0xc6,
+	0x28, 0xe2, 0xe0, 0x68, 0xe0, 0x0c, 0x7b, 0xe3, 0xe3, 0x8a, 0xe2, 0xa2, 0x80, 0x69, 0xe5, 0x3f,
-	0xb0, 0x3f, 0x75, 0xba, 0x7a, 0x2e, 0xb6, 0x82, 0xe5, 0x3c, 0xb9, 0x31, 0x39, 0x5a, 0x51, 0x7e,
+	0xa1, 0xe0, 0x3d, 0xd6, 0x91, 0xf8, 0xd0, 0x7c, 0xc0, 0x8d, 0xed, 0x46, 0x97, 0x9a, 0x4f, 0xf2,
-	0xe9, 0xff, 0xec, 0x1c, 0x5e, 0xc3, 0x17, 0x4f, 0xbc, 0xfa, 0x89, 0xc6, 0xd1, 0xe3, 0xc6, 0x93,
+	0x1a, 0x0e, 0xd7, 0x2c, 0x59, 0x61, 0xd0, 0xb0, 0x64, 0x75, 0xe9, 0x57, 0x1b, 0xc1, 0x52, 0x1e,
-	0xa6, 0xb1, 0xa9, 0xea, 0x34, 0x8c, 0xfe, 0x02, 0xaf, 0xf2, 0x89, 0x7c, 0x07, 0x1e, 0x4b, 0x74,
+	0xdd, 0x19, 0x1f, 0x2d, 0x42, 0x7e, 0x6a, 0xfc, 0xe8, 0x9c, 0xdc, 0xc2, 0x67, 0x4f, 0x64, 0xf9,
-	0xb3, 0x02, 0xfe, 0xb1, 0xdf, 0x94, 0x9c, 0x5a, 0x94, 0xd6, 0x59, 0xf2, 0x3d, 0x78, 0xb6, 0xbc,
+	0x04, 0x71, 0xf8, 0x98, 0xb8, 0x5f, 0x11, 0x9b, 0x53, 0x3b, 0x84, 0x21, 0x87, 0x76, 0x99, 0x38,
-	0x59, 0x87, 0xa7, 0xcf, 0x5c, 0x73, 0xa2, 0xff, 0x06, 0xf0, 0xe2, 0xe9, 0x29, 0x93, 0x6f, 0x60,
+	0x21, 0xe0, 0xea, 0x4d, 0x8e, 0x25, 0x8b, 0xfd, 0x26, 0xdf, 0x42, 0x2b, 0xca, 0xc4, 0x3d, 0x5f,
-	0x9c, 0x17, 0xe9, 0x3a, 0xc3, 0x65, 0xc9, 0xf4, 0xaa, 0x3e, 0x3c, 0x54, 0xd0, 0x82, 0xe9, 0x15,
+	0xec, 0x4d, 0xb0, 0x8c, 0x21, 0x2f, 0xa0, 0xfb, 0x57, 0x26, 0x1f, 0x54, 0xce, 0x22, 0x0c, 0x9a,
-	0xf9, 0x0d, 0xdc, 0xbc, 0x48, 0x2b, 0x09, 0xfe, 0xf1, 0x9b, 0xdd, 0x4b, 0xd3, 0xc2, 0x1f, 0x8a,
+	0x96, 0x66, 0x0b, 0x84, 0x7f, 0x40, 0xab, 0xe8, 0x1e, 0xf9, 0x1a, 0x5a, 0x2c, 0xd2, 0xd5, 0x60,
-	0x14, 0xa9, 0x2d, 0x24, 0x04, 0x5c, 0xbd, 0x2d, 0x31, 0x1c, 0xd8, 0xd6, 0xf6, 0xd9, 0x60, 0x82,
+	0x7a, 0x63, 0xaf, 0x62, 0x3d, 0xb7, 0x28, 0x2d, 0xbd, 0xe6, 0x76, 0x9b, 0x69, 0x35, 0xa4, 0xff,
-	0xe5, 0x18, 0xba, 0x15, 0x66, 0x9e, 0x09, 0x81, 0x81, 0xd2, 0x32, 0xdc, 0x33, 0xd0, 0x65, 0x8f,
+	0x73, 0x7b, 0x11, 0x13, 0xfe, 0xdb, 0x84, 0xe7, 0x4f, 0xcf, 0x1e, 0xf9, 0x12, 0x7a, 0x69, 0x16,
-	0x9a, 0xc0, 0x60, 0x5c, 0xe8, 0xd0, 0x9b, 0x3a, 0xb3, 0x81, 0xc1, 0xb8, 0xd0, 0xe6, 0xc4, 0x29,
+	0xaf, 0x12, 0x9c, 0xe5, 0x4c, 0x2f, 0xcb, 0x0a, 0xa1, 0x80, 0xa6, 0x4c, 0x2f, 0xc9, 0x2f, 0xe0,
-	0x96, 0x85, 0xc2, 0x74, 0x69, 0xec, 0xde, 0xaf, 0x4e, 0x5c, 0x43, 0xef, 0x70, 0x4b, 0x0e, 0x61,
+	0xa6, 0x59, 0x5c, 0xa8, 0xe5, 0x8d, 0xdf, 0xec, 0x1f, 0xe5, 0x1a, 0xfe, 0x90, 0xc5, 0x48, 0xed,
-	0xd8, 0x2c, 0x41, 0x38, 0xb4, 0xd9, 0x36, 0x36, 0xfe, 0x56, 0xcb, 0x1b, 0x8e, 0xec, 0x48, 0x5a,
+	0xc1, 0x5a, 0xbc, 0xe6, 0x8e, 0x78, 0x04, 0x5c, 0xc1, 0x52, 0x0c, 0xdc, 0x02, 0x33, 0xdf, 0x84,
-	0x7f, 0xeb, 0xad, 0xad, 0xb3, 0x64, 0x0e, 0xfb, 0xa5, 0xe4, 0x1b, 0xa6, 0x31, 0x84, 0x1d, 0x4b,
+	0x40, 0x53, 0x69, 0x19, 0x1c, 0x1a, 0xe8, 0xfa, 0x80, 0x1a, 0xc3, 0x60, 0x5c, 0xe8, 0xa0, 0x35,
-	0xd1, 0x90, 0xc8, 0x89, 0xb9, 0x66, 0x7f, 0xaf, 0xb9, 0xc4, 0x74, 0x29, 0xb1, 0xcc, 0x58, 0x82,
+	0x70, 0x86, 0x4d, 0x83, 0x71, 0xa1, 0x4d, 0xc6, 0x31, 0xe6, 0x99, 0xc2, 0x78, 0x66, 0x3a, 0xdb,
-	0xe1, 0xd8, 0x4e, 0xa6, 0x1d, 0xba, 0x71, 0xd3, 0x5c, 0xaa, 0x8a, 0x45, 0x2b, 0x52, 0xf4, 0x2d,
+	0x2e, 0x32, 0x2e, 0xa1, 0x77, 0xb8, 0x21, 0x27, 0xd0, 0xa9, 0x46, 0x33, 0xe8, 0x58, 0x6f, 0x6d,
-	0x4c, 0xba, 0x9e, 0x91, 0x31, 0xec, 0xe7, 0x4c, 0xb0, 0x7b, 0x4c, 0x83, 0x1e, 0x19, 0x82, 0x9b,
+	0x1b, 0x7d, 0x8b, 0x95, 0x0a, 0xba, 0xb6, 0x6b, 0xb5, 0xbe, 0xe5, 0x2e, 0x95, 0x5e, 0x32, 0x82,
-	0x32, 0xcd, 0x02, 0xe7, 0xcc, 0x87, 0x09, 0xaf, 0x9d, 0x36, 0xaa, 0xa3, 0x15, 0x4c, 0xba, 0xb7,
+	0x76, 0x2e, 0xf9, 0x9a, 0x69, 0x0c, 0x60, 0x4f, 0x7b, 0xab, 0x20, 0x72, 0x66, 0x96, 0xff, 0xcf,
-	0xad, 0x35, 0xd4, 0xe9, 0x18, 0xfa, 0xa0, 0xb5, 0xbf, 0x53, 0xeb, 0xd7, 0x30, 0x52, 0x28, 0x14,
+	0x15, 0x97, 0x18, 0xcf, 0x24, 0xe6, 0x89, 0x69, 0x73, 0xcf, 0x76, 0xa6, 0x9e, 0x2f, 0xa3, 0xa6,
-	0xd7, 0x7c, 0x53, 0x4d, 0x69, 0x48, 0x1f, 0x80, 0x68, 0x06, 0x93, 0xae, 0x64, 0xf3, 0x95, 0xca,
+	0x59, 0xf5, 0x22, 0x8a, 0x16, 0x41, 0xe1, 0x57, 0xd0, 0xdf, 0xd5, 0x8c, 0xf4, 0xa0, 0x9d, 0x32,
-	0xd5, 0x7d, 0xc9, 0x92, 0xcf, 0xf6, 0x65, 0x13, 0xda, 0x84, 0xd1, 0x4b, 0x70, 0xcd, 0x62, 0x93,
+	0xc1, 0x16, 0x18, 0xfb, 0x07, 0xa4, 0x03, 0x6e, 0xcc, 0x34, 0xf3, 0x9d, 0x0b, 0x0f, 0xfa, 0xbc,
-	0x17, 0xe0, 0xa9, 0x15, 0x3b, 0xfe, 0xf1, 0xa7, 0x9a, 0x50, 0x47, 0xd1, 0xbf, 0x0e, 0xb8, 0x76,
+	0x54, 0xda, 0x54, 0x1d, 0x2e, 0xa1, 0xbf, 0xfb, 0x06, 0xd4, 0x82, 0x3a, 0x3b, 0x82, 0x6e, 0x6b,
-	0xa5, 0x5e, 0xc1, 0x9e, 0xd2, 0x58, 0xaa, 0xd0, 0xb1, 0x0e, 0x3d, 0xef, 0x3a, 0x34, 0xff, 0x5d,
+	0x6d, 0xec, 0xad, 0xf5, 0x05, 0x74, 0x15, 0x0a, 0xc5, 0x35, 0x5f, 0x17, 0x5d, 0xea, 0xd0, 0x2d,
-	0x63, 0x49, 0xab, 0xfc, 0xa1, 0x06, 0xd7, 0x84, 0xe4, 0x15, 0xf8, 0x4c, 0x6b, 0xc9, 0x6f, 0xd7,
+	0x10, 0x0e, 0xa1, 0xbf, 0x5b, 0xb2, 0x79, 0x3b, 0x53, 0xb5, 0xc8, 0x59, 0xf4, 0x60, 0x2f, 0xeb,
-	0x1a, 0x97, 0x0f, 0x3a, 0x2f, 0x7b, 0xf4, 0x59, 0x8b, 0x7f, 0x34, 0x92, 0x4f, 0x60, 0x8c, 0x19,
+	0xd3, 0xca, 0x0c, 0x5f, 0x82, 0x6b, 0x76, 0x88, 0x3c, 0x87, 0x96, 0x5a, 0xb2, 0xf1, 0xf7, 0x3f,
-	0xe6, 0x28, 0xb4, 0xdd, 0x8d, 0x1d, 0xf7, 0xf9, 0xb2, 0x47, 0xa1, 0xa6, 0xbe, 0xc3, 0xed, 0x19,
+	0x94, 0x01, 0xa5, 0x15, 0xfe, 0xed, 0x80, 0x6b, 0x47, 0xea, 0x15, 0x1c, 0x2a, 0x8d, 0xb9, 0x0a,
-	0xc0, 0x50, 0x61, 0x86, 0x89, 0x2e, 0xe4, 0xeb, 0x0f, 0xe0, 0x55, 0xb7, 0xcd, 0xf8, 0xff, 0xf1,
+	0x1c, 0xab, 0xd0, 0xb3, 0x5d, 0x85, 0x46, 0xbf, 0x6a, 0xcc, 0x69, 0xe1, 0x3f, 0xd1, 0xe0, 0x1a,
-	0xfa, 0x7a, 0x11, 0xf4, 0x08, 0x80, 0x77, 0x4e, 0xe3, 0xd3, 0x4f, 0x71, 0xe0, 0x18, 0x94, 0xc6,
+	0x93, 0xbc, 0x02, 0x8f, 0x69, 0x2d, 0xf9, 0x7c, 0xa5, 0x71, 0xb6, 0xad, 0xf3, 0xfa, 0x80, 0x1e,
-	0xa7, 0x17, 0x41, 0xdf, 0xa0, 0x7f, 0x2c, 0x2e, 0x0c, 0x3a, 0x30, 0x83, 0xa3, 0xf1, 0xe2, 0xfd,
+	0xd5, 0xf8, 0x47, 0x53, 0xf2, 0x19, 0xf4, 0x30, 0xc1, 0x14, 0x85, 0xb6, 0xb3, 0xb1, 0x67, 0x33,
-	0xe9, 0x79, 0x1c, 0xb8, 0x26, 0x71, 0x11, 0xbf, 0x8f, 0x3f, 0xc5, 0xc1, 0xde, 0xd9, 0xdb, 0x3f,
+	0xaf, 0x0f, 0x28, 0x94, 0xa1, 0xef, 0x70, 0x73, 0x01, 0xd0, 0x51, 0x98, 0x60, 0xa4, 0x33, 0xf9,
-	0x4f, 0xee, 0xb9, 0x5e, 0xad, 0x6f, 0xe7, 0x49, 0x91, 0x1f, 0x99, 0xcf, 0x19, 0x4f, 0x0a, 0x59,
+	0xfa, 0x03, 0xb4, 0x8a, 0x6d, 0x33, 0xfa, 0x7f, 0xbc, 0xbd, 0x9d, 0xfa, 0x07, 0x04, 0xa0, 0x75,
-	0x1e, 0xb5, 0x5f, 0xbd, 0x23, 0x73, 0x38, 0x75, 0xc4, 0x85, 0x46, 0x29, 0x58, 0x66, 0x43, 0xfb,
+	0x49, 0x27, 0xe7, 0x9f, 0x26, 0xbe, 0x63, 0x50, 0x3a, 0x39, 0xbf, 0xf2, 0x1b, 0x06, 0xfd, 0x6d,
-	0x17, 0x71, 0xeb, 0xd9, 0x9f, 0x1f, 0xfe, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x57, 0x66, 0x84, 0xc3,
+	0x7a, 0x65, 0xd0, 0xa6, 0x69, 0x1c, 0x9d, 0x4c, 0xdf, 0x9f, 0x5f, 0x4e, 0x7c, 0xd7, 0x38, 0xae,
-	0x3b, 0x06, 0x00, 0x00,
+	0x26, 0xef, 0x27, 0x9f, 0x26, 0xfe, 0xe1, 0xc5, 0xdb, 0xdf, 0xcf, 0x16, 0x5c, 0x2f, 0x57, 0xf3,
+	0x51, 0x94, 0xa5, 0xa7, 0xe6, 0x91, 0xe5, 0x51, 0x26, 0xf3, 0xd3, 0xfa, 0x2d, 0x3e, 0x35, 0xc9,
+	0xa9, 0x53, 0x2e, 0x34, 0x4a, 0xc1, 0x12, 0x6b, 0xda, 0x3f, 0xae, 0x79, 0xcb, 0xfe, 0x7c, 0xf7,
+	0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x95, 0x91, 0xf6, 0x8e, 0xd1, 0x06, 0x00, 0x00,
 }

plans/internal/planproto/planfile.proto

@@ -38,6 +38,17 @@ message Plan {
     // SHA256 digests of all of the provider plugin binaries that were used
     // in the creation of this plan.
     map<string, Hash> provider_hashes = 15;
+
+    // Backend is a description of the backend configuration and other related
+    // settings at the time the plan was created.
+    Backend backend = 13;
+}
+
+// Backend is a description of backend configuration and other related settings.
+message Backend {
+    string type = 1;
+    DynamicValue config = 2;
+    string workspace = 3;
 }
 
 // Action describes the type of action planned for an object.

plans/plan.go

@@ -21,6 +21,26 @@ type Plan struct {
 	VariableValues  map[string]DynamicValue
 	Changes         *Changes
 	ProviderSHA256s map[string][]byte
+	Backend         Backend
+}
+
+// Backend represents the backend-related configuration and other data as it
+// existed when a plan was created.
+type Backend struct {
+	// Type is the type of backend that the plan will apply against.
+	Type string
+
+	// Config is the configuration of the backend, whose schema is decided by
+	// the backend Type.
+	Config DynamicValue
+
+	// Workspace is the name of the workspace that was active when the plan
+	// was created. It is illegal to apply a plan created for one workspace
+	// to the state of another workspace.
+	// (This constraint is already enforced by the statefile lineage mechanism,
+	// but storing this explicitly allows us to return a better error message
+	// in the situation where the user has the wrong workspace selected.)
+	Workspace string
 }
 
 // ProviderAddrs returns a list of all of the provider configuration addresses

plans/planfile/planfile_test.go

@@ -52,6 +52,11 @@ func TestRoundtrip(t *testing.T) {
 		VariableValues: map[string]plans.DynamicValue{
 			"foo": plans.DynamicValue([]byte("foo placeholder")),
 		},
+		Backend: plans.Backend{
+			Type:      "local",
+			Config:    plans.DynamicValue([]byte("config placeholder")),
+			Workspace: "default",
+		},
 	}
 
 	workDir, err := ioutil.TempDir("", "tf-planfile")

plans/planfile/tfplan.go

@@ -98,6 +98,20 @@ func readTfplan(r io.Reader) (*plans.Plan, error) {
 		plan.VariableValues[name] = val
 	}
 
+	if rawBackend := rawPlan.Backend; rawBackend == nil {
+		return nil, fmt.Errorf("plan file has no backend settings; backend settings are required")
+	} else {
+		config, err := valueFromTfplan(rawBackend.Config)
+		if err != nil {
+			return nil, fmt.Errorf("plan file has invalid backend configuration: %s", err)
+		}
+		plan.Backend = plans.Backend{
+			Type:      rawBackend.Type,
+			Config:    config,
+			Workspace: rawBackend.Workspace,
+		}
+	}
+
 	return plan, nil
 }
 
@@ -296,6 +310,12 @@ func writeTfplan(plan *plans.Plan, w io.Writer) error {
 		rawPlan.Variables[name] = valueToTfplan(val)
 	}
 
+	rawPlan.Backend = &planproto.Backend{
+		Type:      plan.Backend.Type,
+		Config:    valueToTfplan(plan.Backend.Config),
+		Workspace: plan.Backend.Workspace,
+	}
+
 	src, err := proto.Marshal(rawPlan)
 	if err != nil {
 		return fmt.Errorf("serialization error: %s", err)

plans/planfile/tfplan_test.go

@@ -93,6 +93,18 @@ func TestTFPlanRoundTrip(t *testing.T) {
 				0x70, 0x7a, 0x11, 0xed, 0xb0, 0x07, 0xab, 0x1e,
 			},
 		},
+		Backend: plans.Backend{
+			Type: "local",
+			Config: mustNewDynamicValue(
+				cty.ObjectVal(map[string]cty.Value{
+					"foo": cty.StringVal("bar"),
+				}),
+				cty.Object(map[string]cty.Type{
+					"foo": cty.String,
+				}),
+			),
+			Workspace: "default",
+		},
 	}
 
 	var buf bytes.Buffer