Improve error handling

Author: wata727

plugin/plugin.go

@@ -35,6 +35,7 @@ func (RuleSetPlugin) Client(b *plugin.MuxBroker, c *rpc.Client) (interface{}, er
 // In order to communicate the interface correctly with RPC,
 // the type of the related structure is registered in gob at the initial time.
 func init() {
+	gob.Register(tflint.Error{})
 	// https://github.com/hashicorp/hcl/blob/v2.0.0/hclsyntax/expression.go
 	gob.Register(&hclsyntax.LiteralValueExpr{})
 	gob.Register(&hclsyntax.ScopeTraversalExpr{})

tflint/client.go

@@ -28,15 +28,24 @@ type AttributesRequest struct {
 	AttributeName string
 }
 
+// AttributesResponse is the interface used to communicate via RPC.
+type AttributesResponse struct {
+	Attributes hcl.Attributes
+	Err        error
+}
+
 // WalkResourceAttributes queries the host process, receives a list of attributes that match the conditions,
 // and passes each to the walker function.
 func (c *Client) WalkResourceAttributes(resource, attributeName string, walker func(*hcl.Attribute) error) error {
-	var resp hcl.Attributes
-	if err := c.rpcClient.Call("Plugin.Attributes", AttributesRequest{Resource: resource, AttributeName: attributeName}, &resp); err != nil {
+	var response AttributesResponse
+	if err := c.rpcClient.Call("Plugin.Attributes", AttributesRequest{Resource: resource, AttributeName: attributeName}, &response); err != nil {
 		return err
 	}
+	if response.Err != nil {
+		return response.Err
+	}
 
-	for _, attribute := range resp {
+	for _, attribute := range response.Attributes {
 		if err := walker(attribute); err != nil {
 			return err
 		}
@@ -51,17 +60,26 @@ type EvalExprRequest struct {
 	Ret  interface{}
 }
 
+// EvalExprResponse is the interface used to communicate with RPC.
+type EvalExprResponse struct {
+	Val cty.Value
+	Err error
+}
+
 // EvaluateExpr queries the host process for the result of evaluating the value of the passed expression
 // and reflects it as the value of the second argument based on that.
 func (c *Client) EvaluateExpr(expr hcl.Expression, ret interface{}) error {
-	var val cty.Value
+	var response EvalExprResponse
 	var err error
 
-	if err := c.rpcClient.Call("Plugin.EvalExpr", EvalExprRequest{Expr: expr, Ret: ret}, &val); err != nil {
+	if err := c.rpcClient.Call("Plugin.EvalExpr", EvalExprRequest{Expr: expr, Ret: ret}, &response); err != nil {
 		return err
 	}
+	if response.Err != nil {
+		return response.Err
+	}
 
-	err = gocty.FromCtyValue(val, ret)
+	err = gocty.FromCtyValue(response.Val, ret)
 	if err != nil {
 		err := &Error{
 			Code:  TypeMismatchError,
@@ -110,7 +128,7 @@ func (*Client) EnsureNoError(err error, proc func() error) error {
 		return proc()
 	}
 
-	if appErr, ok := err.(*Error); ok {
+	if appErr, ok := err.(Error); ok {
 		switch appErr.Level {
 		case WarningLevel:
 			return nil

tflint/errors.go

@@ -4,41 +4,43 @@ import "fmt"
 
 const (
 	// EvaluationError is an error when interpolation failed (unexpected)
-	EvaluationError int = 0
+	EvaluationError string = "E:Evaluation"
 	// UnknownValueError is an error when an unknown value is referenced
-	UnknownValueError int = 1 + iota
+	UnknownValueError string = "W:UnknownValue"
 	// NullValueError is an error when null value is referenced
-	NullValueError
+	NullValueError string = "W:NullValue"
 	// TypeConversionError is an error when type conversion of cty.Value failed
-	TypeConversionError
+	TypeConversionError string = "E:TypeConversion"
 	// TypeMismatchError is an error when a type of cty.Value is not as expected
-	TypeMismatchError
+	TypeMismatchError string = "E:TypeMismatch"
 	// UnevaluableError is an error when a received expression has unevaluable references.
-	UnevaluableError
+	UnevaluableError string = "W:Unevaluable"
 	// UnexpectedAttributeError is an error when handle unexpected attributes (e.g. block)
-	UnexpectedAttributeError
+	UnexpectedAttributeError string = "E:UnexpectedAttribute"
 	// ExternalAPIError is an error when calling the external API (e.g. AWS SDK)
-	ExternalAPIError
+	ExternalAPIError string = "E:ExternalAPI"
+	// ContextError is pseudo error code for propagating runtime context.
+	ContextError string = "I:Context"
 
 	// FatalLevel is a recorverable error, it cause panic
-	FatalLevel int = 0
+	FatalLevel string = "Fatal"
 	// ErrorLevel is a user-level error, it display and feedback error information
-	ErrorLevel int = 1 + iota
+	ErrorLevel string = "Error"
 	// WarningLevel is a user-level warning. Although it is an error, it has no effect on execution.
-	WarningLevel
+	WarningLevel string = "Warning"
 )
 
 // Error is application error object. It has own error code
 // for processing according to a type of error.
 type Error struct {
-	Code    int
-	Level   int
+	Code    string
+	Level   string
 	Message string
 	Cause   error
 }
 
 // Error shows error message. This must be implemented for error interface.
-func (e *Error) Error() string {
+func (e Error) Error() string {
 	if e.Message != "" && e.Cause != nil {
 		return fmt.Sprintf("%s; %s", e.Message, e.Cause)
 	}

tflint/interface.go

@@ -2,7 +2,6 @@ package tflint
 
 import (
 	"github.com/hashicorp/hcl/v2"
-	"github.com/zclconf/go-cty/cty"
 )
 
 // Runner acts as a client for each plugin to query the host process about the Terraform configurations.
@@ -24,7 +23,7 @@ type Rule interface {
 
 // Server is the interface that hosts that provide the plugin mechanism must meet in order to respond to queries from the plugin.
 type Server interface {
-	Attributes(*AttributesRequest, *hcl.Attributes) error
-	EvalExpr(*EvalExprRequest, *cty.Value) error
+	Attributes(*AttributesRequest, *AttributesResponse) error
+	EvalExpr(*EvalExprRequest, *EvalExprResponse) error
 	EmitIssue(*EmitIssueRequest, *interface{}) error
 }