compileopts: improve error reporting of unsupported flags

compileopts/options.go

@@ -1,5 +1,25 @@
 package compileopts
 
+import (
+	"fmt"
+	"strings"
+)
+
+var (
+	validGCOptions        = []string{"none", "leaking", "extalloc", "conservative"}
+	validSchedulerOptions = []string{"tasks", "coroutines"}
+	validPrintSizeOptions = []string{"none", "short", "full"}
+	// ErrGCInvalidOption is an error raised if gc option is not valid
+	ErrGCInvalidOption = fmt.Errorf(`invalid gc option: valid values are %s`,
+		strings.Join(validGCOptions, ", "))
+	// ErrSchedulerInvalidOption is an error raised if scheduler option is not valid
+	ErrSchedulerInvalidOption = fmt.Errorf(`invalid scheduler option: valid values are %s`,
+		strings.Join(validSchedulerOptions, ", "))
+	//ErrPrintSizeInvalidOption is an error raised if size option is not valid
+	ErrPrintSizeInvalidOption = fmt.Errorf(`invalid size option: valid values are %s`,
+		strings.Join(validPrintSizeOptions, ", "))
+)
+
 // Options contains extra options to give to the compiler. These options are
 // usually passed from the command line.
 type Options struct {
@@ -21,3 +41,42 @@ type Options struct {
 	TestConfig    TestConfig
 	Programmer    string
 }
+
+// Verify performs a validation on the given options, raising an error is options are not valid
+// In particular:
+// ErrGCInvalidOption will be reised if gc is not valid
+// ErrSchedulerInvalidOption will be reised if scheduler is not valid
+// ErrPrintSizeInvalidOption will be reised if size is not valid
+func (o *Options) Verify() error {
+	if o.GC != "" {
+		valid := isInArray(validGCOptions, o.GC)
+		if !valid {
+			return ErrGCInvalidOption
+		}
+	}
+
+	if o.Scheduler != "" {
+		valid := isInArray(validSchedulerOptions, o.Scheduler)
+		if !valid {
+			return ErrSchedulerInvalidOption
+		}
+	}
+
+	if o.PrintSizes != "" {
+		valid := isInArray(validPrintSizeOptions, o.PrintSizes)
+		if !valid {
+			return ErrPrintSizeInvalidOption
+		}
+	}
+
+	return nil
+}
+
+func isInArray(arr []string, item string) bool {
+	for _, i := range arr {
+		if i == item {
+			return true
+		}
+	}
+	return false
+}

compileopts/options_test.go

@@ -0,0 +1,122 @@
+package compileopts_test
+
+import (
+	"testing"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+)
+
+func TestOptions_Verify(t *testing.T) {
+	testCases := []struct {
+		name          string
+		opts          compileopts.Options
+		expectedError error
+	}{
+		{
+			name: "it returns no error if Options is empty",
+			opts: compileopts.Options{},
+		},
+		{
+			name: "it returns an error if gc option is not valid",
+			opts: compileopts.Options{
+				GC: "incorrect",
+			},
+			expectedError: compileopts.ErrGCInvalidOption,
+		},
+		{
+			name: "it returns no error if gc option is 'none'",
+			opts: compileopts.Options{
+				GC: "none",
+			},
+		},
+		{
+			name: "it returns no error if gc option is 'leaking'",
+			opts: compileopts.Options{
+				GC: "leaking",
+			},
+		},
+		{
+			name: "it returns no error if gc option is 'extalloc'",
+			opts: compileopts.Options{
+				GC: "extalloc",
+			},
+		},
+		{
+			name: "it returns no error if gc option is 'conservative'",
+			opts: compileopts.Options{
+				GC: "conservative",
+			},
+		},
+		{
+			name: "it returns no error if gc option is empty",
+			opts: compileopts.Options{
+				GC: "",
+			},
+		},
+		{
+			name: "it returns an error if scheduler option is not valid",
+			opts: compileopts.Options{
+				Scheduler: "incorrect",
+			},
+			expectedError: compileopts.ErrSchedulerInvalidOption,
+		},
+		{
+			name: "it returns no error if scheduler option is 'tasks'",
+			opts: compileopts.Options{
+				Scheduler: "tasks",
+			},
+		},
+		{
+			name: "it returns no error if scheduler option is 'coroutines'",
+			opts: compileopts.Options{
+				Scheduler: "coroutines",
+			},
+		},
+		{
+			name: "it returns no error if scheduler option is empty",
+			opts: compileopts.Options{
+				Scheduler: "",
+			},
+		},
+		{
+			name: "it returns an error if printSize option is not valid",
+			opts: compileopts.Options{
+				PrintSizes: "invalid",
+			},
+			expectedError: compileopts.ErrPrintSizeInvalidOption,
+		},
+		{
+			name: "it returns no error if printSize option is 'none'",
+			opts: compileopts.Options{
+				PrintSizes: "none",
+			},
+		},
+		{
+			name: "it returns no error if printSize option is 'short'",
+			opts: compileopts.Options{
+				PrintSizes: "short",
+			},
+		},
+		{
+			name: "it returns no error if printSize option is 'full'",
+			opts: compileopts.Options{
+				PrintSizes: "full",
+			},
+		},
+		{
+			name: "it returns no error if printSize option is empty",
+			opts: compileopts.Options{
+				PrintSizes: "",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := tc.opts.Verify()
+			if tc.expectedError != err {
+				t.Errorf("expecting %v, got %v", tc.expectedError, err)
+			}
+		})
+	}
+}

main.go

@@ -762,6 +762,13 @@ func main() {
 		Programmer:    *programmer,
 	}
 
+	err := options.Verify()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err.Error())
+		usage()
+		os.Exit(1)
+	}
+
 	if *cFlags != "" {
 		options.CFlags = strings.Split(*cFlags, " ")
 	}
@@ -776,7 +783,6 @@ func main() {
 		os.Exit(1)
 	}
 
-	var err error
 	if options.HeapSize, err = parseSize(*heapSize); err != nil {
 		fmt.Fprintln(os.Stderr, "Could not read heap size:", *heapSize)
 		usage()