feat: categorize more flux errors with codes

This covers all of the packages that are in active use within the flux
repository. It doesn't cover all of the packages, but enough that we
should have good enough coverage for most code paths that get hit.

Author: jsternberg

compile.go

@@ -2,7 +2,6 @@ package flux
 
 import (
 	"context"
-	stderrors "errors"
 	"fmt"
 	"path"
 	"regexp"
@@ -256,10 +255,10 @@ func Prelude() values.Scope {
 // RegisterPackage adds a builtin package
 func RegisterPackage(pkg *ast.Package) {
 	if finalized {
-		panic(stderrors.New("already finalized, cannot register builtin package"))
+		panic(errors.New(codes.Internal, "already finalized, cannot register builtin package"))
 	}
 	if _, ok := builtinPackages[pkg.Path]; ok {
-		panic(fmt.Errorf("duplicate builtin package %q", pkg.Path))
+		panic(errors.Newf(codes.Internal, "duplicate builtin package %q", pkg.Path))
 	}
 	builtinPackages[pkg.Path] = pkg
 	_, ok := stdlib.pkgs[pkg.Path]
@@ -282,7 +281,7 @@ func ReplacePackageValue(pkgpath, name string, value values.Value) {
 
 func registerPackageValue(pkgpath, name string, value values.Value, replace bool) {
 	if finalized {
-		panic(stderrors.New("already finalized, cannot register builtin package value"))
+		panic(errors.Newf(codes.Internal, "already finalized, cannot register builtin package value"))
 	}
 	packg, ok := stdlib.pkgs[pkgpath]
 	if !ok {
@@ -292,9 +291,9 @@ func registerPackageValue(pkgpath, name string, value values.Value, replace bool
 		stdlib.pkgs[pkgpath] = packg
 	}
 	if _, ok := packg.Get(name); ok && !replace {
-		panic(fmt.Errorf("duplicate builtin package value %q %q", pkgpath, name))
+		panic(errors.Newf(codes.Internal, "duplicate builtin package value %q %q", pkgpath, name))
 	} else if !ok && replace {
-		panic(fmt.Errorf("missing builtin package value %q %q", pkgpath, name))
+		panic(errors.Newf(codes.Internal, "missing builtin package value %q %q", pkgpath, name))
 	}
 	packg.Set(name, value)
 }
@@ -318,7 +317,7 @@ func FunctionValueWithSideEffect(name string, c CreateOperationSpec, sig semanti
 func functionValue(name string, c CreateOperationSpec, sig semantic.FunctionPolySignature, sideEffects bool) values.Value {
 	if c == nil {
 		c = func(args Arguments, a *Administration) (OperationSpec, error) {
-			return nil, fmt.Errorf("function %q is not implemented", name)
+			return nil, errors.Newf(codes.Unimplemented, "function %q is not implemented", name)
 		}
 	}
 	return &function{
@@ -409,7 +408,7 @@ func validatePackageBuiltins(pkg *interpreter.Package, astPkg *ast.Package) erro
 		}
 	})
 	if len(missing) > 0 || len(extra) > 0 {
-		return fmt.Errorf("missing builtin values %v, extra builtin values %v", missing, extra)
+		return errors.Newf(codes.Internal, "missing builtin values %v, extra builtin values %v", missing, extra)
 	}
 	return nil
 }
@@ -621,7 +620,7 @@ func (a *Administration) AddParentFromArgs(args Arguments) error {
 	}
 	p, ok := parent.(*TableObject)
 	if !ok {
-		return fmt.Errorf("argument is not a table object: got %T", parent)
+		return errors.Newf(codes.Invalid, "argument is not a table object: got %T", parent)
 	}
 	a.AddParent(p)
 	return nil
@@ -753,7 +752,7 @@ func (a Arguments) GetRequiredTime(name string) (Time, error) {
 		return Time{}, err
 	}
 	if !ok {
-		return Time{}, fmt.Errorf("missing required keyword argument %q", name)
+		return Time{}, errors.Newf(codes.Invalid, "missing required keyword argument %q", name)
 	}
 	return qt, nil
 }
@@ -772,7 +771,7 @@ func (a Arguments) GetRequiredDuration(name string) (Duration, error) {
 		return ConvertDuration(0), err
 	}
 	if !ok {
-		return ConvertDuration(0), fmt.Errorf("missing required keyword argument %q", name)
+		return ConvertDuration(0), errors.Newf(codes.Invalid, "missing required keyword argument %q", name)
 	}
 	return d, nil
 }
@@ -793,7 +792,7 @@ func ToQueryTime(value values.Value) (Time, error) {
 			Absolute: time.Unix(value.Int(), 0),
 		}, nil
 	default:
-		return Time{}, fmt.Errorf("value is not a time, got %v", value.Type())
+		return Time{}, errors.Newf(codes.Invalid, "value is not a time, got %v", value.Type())
 	}
 }
 
@@ -854,7 +853,7 @@ func insertPkg(pkg *ast.Package, pkgs map[string]*ast.Package, order []*ast.Pack
 	for _, path := range imports {
 		dep, ok := pkgs[path]
 		if !ok {
-			return nil, fmt.Errorf("unknown builtin package %q", path)
+			return nil, errors.Newf(codes.Invalid, "unknown builtin package %q", path)
 		}
 		order, err = insertPkg(dep, pkgs, order)
 		if err != nil {

compiler.go

@@ -2,8 +2,9 @@ package flux
 
 import (
 	"context"
-	"fmt"
 
+	"github.com/influxdata/flux/codes"
+	"github.com/influxdata/flux/internal/errors"
 	"github.com/influxdata/flux/memory"
 )
 
@@ -21,7 +22,7 @@ type CompilerMappings map[CompilerType]CreateCompiler
 
 func (m CompilerMappings) Add(t CompilerType, c CreateCompiler) error {
 	if _, ok := m[t]; ok {
-		return fmt.Errorf("duplicate compiler mapping for %q", t)
+		return errors.Newf(codes.Internal, "duplicate compiler mapping for %q", t)
 	}
 	m[t] = c
 	return nil

compiler/compiler.go

@@ -1,9 +1,6 @@
 package compiler
 
 import (
-	stderrors "errors"
-	"fmt"
-
 	"github.com/influxdata/flux"
 	"github.com/influxdata/flux/codes"
 	"github.com/influxdata/flux/internal/errors"
@@ -16,7 +13,7 @@ func Compile(scope Scope, f *semantic.FunctionExpression, in semantic.Type) (Fun
 		scope = NewScope()
 	}
 	if in.Nature() != semantic.Object {
-		return nil, fmt.Errorf("function input must be an object @ %v", f.Location())
+		return nil, errors.Newf(codes.Invalid, "function input must be an object @ %v", f.Location())
 	}
 	extern := values.BuildExternAssignments(f, scope)
 
@@ -86,7 +83,7 @@ func compile(n semantic.Node, typeSol semantic.TypeSolution, scope Scope, funcEx
 			body: body,
 		}, nil
 	case *semantic.ExpressionStatement:
-		return nil, stderrors.New("statement does nothing, side effects are not supported by the compiler")
+		return nil, errors.New(codes.Internal, "statement does nothing, side effects are not supported by the compiler")
 	case *semantic.ReturnStatement:
 		node, err := compile(n.Argument, typeSol, scope, funcExprs)
 		if err != nil {
@@ -133,7 +130,7 @@ func compile(n semantic.Node, typeSol semantic.TypeSolution, scope Scope, funcEx
 			}
 			with, ok := node.(*identifierEvaluator)
 			if !ok {
-				return nil, stderrors.New("unknown identifier in with expression")
+				return nil, errors.New(codes.Internal, "unknown identifier in with expression")
 			}
 			obj.with = with
 
@@ -396,7 +393,7 @@ func compile(n semantic.Node, typeSol semantic.TypeSolution, scope Scope, funcEx
 			body:   body,
 		}, nil
 	default:
-		return nil, fmt.Errorf("unknown semantic node of type %T", n)
+		return nil, errors.Newf(codes.Internal, "unknown semantic node of type %T", n)
 	}
 }
 
@@ -435,13 +432,13 @@ type funcErr struct {
 	Err error
 }
 
-// Utility function for compiling an `fn` parameter for rename or drop/keep. In addition
+// CompileFnParam is a utility function for compiling an `fn` parameter for rename or drop/keep. In addition
 // to the function expression, it takes two types to verify the result against:
 // a single argument type, and a single return type.
 func CompileFnParam(fn *semantic.FunctionExpression, scope Scope, paramType, returnType semantic.Type) (Func, string, error) {
 	compileCache := NewCompilationCache(fn, scope)
 	if fn.Block.Parameters != nil && len(fn.Block.Parameters.List) != 1 {
-		return nil, "", stderrors.New("function should only have a single parameter")
+		return nil, "", errors.New(codes.Invalid, "function should only have a single parameter")
 	}
 	paramName := fn.Block.Parameters.List[0].Key.Name
 
@@ -453,7 +450,7 @@ func CompileFnParam(fn *semantic.FunctionExpression, scope Scope, paramType, ret
 	}
 
 	if compiled.Type() != returnType {
-		return nil, "", fmt.Errorf("provided function does not evaluate to type %s", returnType.Nature())
+		return nil, "", errors.Newf(codes.Invalid, "provided function does not evaluate to type %s", returnType.Nature())
 	}
 
 	return compiled, paramName, nil

compiler/runtime.go

@@ -2,13 +2,14 @@ package compiler
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"log"
 	"regexp"
 	"strings"
 
 	"github.com/influxdata/flux/ast"
+	"github.com/influxdata/flux/codes"
+	"github.com/influxdata/flux/internal/errors"
 	"github.com/influxdata/flux/semantic"
 	"github.com/influxdata/flux/values"
 )
@@ -34,11 +35,11 @@ func (c compiledFn) validate(input values.Object) error {
 	sig := c.fnType.FunctionSignature()
 	properties := input.Type().Properties()
 	if len(properties) != len(sig.Parameters) {
-		return errors.New("mismatched parameters and properties")
+		return errors.New(codes.Invalid, "mismatched parameters and properties")
 	}
 	for k, v := range sig.Parameters {
 		if !values.AssignableTo(properties[k], v) {
-			return fmt.Errorf("parameter %q has the wrong type, expected %v got %v", k, v, properties[k])
+			return errors.Newf(codes.Invalid, "parameter %q has the wrong type, expected %v got %v", k, v, properties[k])
 		}
 	}
 	return nil
@@ -281,7 +282,7 @@ func (e *logicalEvaluator) Eval(ctx context.Context, scope Scope) (values.Value,
 			return values.NewBool(true), nil
 		}
 	default:
-		panic(fmt.Errorf("unknown logical operator %v", e.operator))
+		panic(errors.Newf(codes.Internal, "unknown logical operator %v", e.operator))
 	}
 
 	r, err := e.right.Eval(ctx, scope)
@@ -370,7 +371,7 @@ func (e *unaryEvaluator) Eval(ctx context.Context, scope Scope) (values.Value, e
 		case ast.SubtractionOperator, ast.NotOperator:
 			// Fallthrough to below.
 		default:
-			return nil, fmt.Errorf("unknown unary operator: %s", e.op)
+			return nil, errors.Newf(codes.Internal, "unknown unary operator: %s", e.op)
 		}
 
 		// The subtraction operator falls through to here.

dialect.go

@@ -1,6 +1,9 @@
 package flux
 
-import "fmt"
+import (
+	"github.com/influxdata/flux/codes"
+	"github.com/influxdata/flux/internal/errors"
+)
 
 // Dialect describes how to encode results.
 type Dialect interface {
@@ -18,7 +21,7 @@ type DialectMappings map[DialectType]CreateDialect
 
 func (m DialectMappings) Add(t DialectType, c CreateDialect) error {
 	if _, ok := m[t]; ok {
-		return fmt.Errorf("duplicate dialect mapping for %q", t)
+		return errors.Newf(codes.Internal, "duplicate dialect mapping for %q", t)
 	}
 	m[t] = c
 	return nil

operation.go

@@ -39,7 +39,7 @@ func (o *Operation) UnmarshalJSON(data []byte) error {
 func unmarshalOpSpec(k OperationKind, data []byte) (OperationSpec, error) {
 	createOpSpec, ok := kindToOp[k]
 	if !ok {
-		return nil, fmt.Errorf("unknown operation spec kind %v", k)
+		return nil, errors.Newf(codes.Invalid, "unknown operation spec kind %v", k)
 	}
 	spec := createOpSpec()
 
@@ -86,7 +86,7 @@ var kindToOp = make(map[OperationKind]NewOperationSpec)
 // TODO:(nathanielc) make this part of RegisterMethod/RegisterFunction
 func RegisterOpSpec(k OperationKind, c NewOperationSpec) {
 	if kindToOp[k] != nil {
-		panic(fmt.Errorf("duplicate registration for operation kind %v", k))
+		panic(errors.Newf(codes.Internal, "duplicate registration for operation kind %v", k))
 	}
 	kindToOp[k] = c
 }

semantic/analyze.go

@@ -1,8 +1,6 @@
 package semantic
 
 import (
-	"fmt"
-
 	"github.com/influxdata/flux/ast"
 	"github.com/influxdata/flux/codes"
 	"github.com/influxdata/flux/internal/errors"
@@ -382,7 +380,7 @@ func analyzeFunctionExpression(arrow *ast.FunctionExpression) (*FunctionExpressi
 		for i, p := range arrow.Params {
 			ident, ok := p.Key.(*ast.Identifier)
 			if !ok {
-				return nil, fmt.Errorf("function params must be identifiers")
+				return nil, errors.New(codes.Invalid, "function params must be identifiers")
 			}
 			key, err := analyzeIdentifier(ident)
 			if err != nil {
@@ -456,11 +454,11 @@ func analyzeCallExpression(call *ast.CallExpression) (*CallExpression, error) {
 	}
 	var args *ObjectExpression
 	if l := len(call.Arguments); l > 1 {
-		return nil, fmt.Errorf("arguments are not a single object expression %v", args)
+		return nil, errors.Newf(codes.Internal, "arguments are not a single object expression %v", args)
 	} else if l == 1 {
 		obj, ok := call.Arguments[0].(*ast.ObjectExpression)
 		if !ok {
-			return nil, fmt.Errorf("arguments not an object expression")
+			return nil, errors.New(codes.Internal, "arguments not an object expression")
 		}
 		var err error
 		args, err = analyzeObjectExpression(obj)

semantic/check.go

@@ -1,6 +1,9 @@
 package semantic
 
-import "fmt"
+import (
+	"github.com/influxdata/flux/codes"
+	"github.com/influxdata/flux/internal/errors"
+)
 
 func runChecks(n Node, vars, opts map[string]bool) error {
 	// Check for options declared below package block.
@@ -43,7 +46,7 @@ func optionStatements(n Node) ([]*OptionStatement, error) {
 		if err != nil {
 			return nil, err
 		}
-		return nil, fmt.Errorf("option %q declared below package block at %v", name, errStmt.Location())
+		return nil, errors.Newf(codes.Invalid, "option %q declared below package block at %v", name, errStmt.Location())
 	}
 	return stmts, nil
 }
@@ -56,11 +59,11 @@ func optionName(opt *OptionStatement) (string, error) {
 		obj := n.Member.Object
 		id, ok := obj.(*IdentifierExpression)
 		if !ok {
-			return "", fmt.Errorf("unsupported option qualifier %T", obj)
+			return "", errors.Newf(codes.Invalid, "unsupported option qualifier %T", obj)
 		}
 		return id.Name + "." + n.Member.Property, nil
 	default:
-		return "", fmt.Errorf("unsupported assignment %T", n)
+		return "", errors.Newf(codes.Internal, "unsupported assignment %T", n)
 	}
 }
 
@@ -98,10 +101,10 @@ func optionReAssignments(stmts []*OptionStatement, vars, options map[string]bool
 			return err
 		}
 		if options[name] {
-			return fmt.Errorf("option %q redeclared at %v", name, stmt.Location())
+			return errors.Newf(codes.Invalid, "option %q redeclared at %v", name, stmt.Location())
 		}
 		if vars[name] {
-			return fmt.Errorf("cannot declare option %q at %v; variable with same name already declared", name, stmt.Location())
+			return errors.Newf(codes.Invalid, "cannot declare option %q at %v; variable with same name already declared", name, stmt.Location())
 		}
 		options[name] = true
 	}
@@ -125,11 +128,11 @@ func varReAssignments(n Node, vars, opts map[string]bool) error {
 	Walk(NewScopedVisitor(visitor), n)
 	if varDec != nil {
 		name := varDec.Identifier.Name
-		return fmt.Errorf("var %q redeclared at %v", name, varDec.Location())
+		return errors.Newf(codes.Invalid, "var %q redeclared at %v", name, varDec.Location())
 	}
 	if optDec != nil {
 		name := optDec.Identifier.Name
-		return fmt.Errorf("cannot declare variable %q at %v; option with same name already declared", name, optDec.Location())
+		return errors.Newf(codes.Invalid, "cannot declare variable %q at %v; option with same name already declared", name, optDec.Location())
 	}
 	return nil
 }
@@ -193,7 +196,7 @@ func optionDependencies(stmts []*OptionStatement, options map[string]bool) error
 		name := n.Identifier.Name
 		Walk(NewScopedVisitor(visitor), n.Init)
 		if dep != nil {
-			return fmt.Errorf("option dependency: option %q depends on option %q defined in the same package at %v", name, dep.Name, dep.Location())
+			return errors.Newf(codes.Invalid, "option dependency: option %q depends on option %q defined in the same package at %v", name, dep.Name, dep.Location())
 		}
 	}
 	return nil