Renaming --rego-v1 cmd flag to --v0-v1

cmd/check.go

@@ -194,9 +194,8 @@ func init() {
 	addCapabilitiesFlag(checkCommand.Flags(), checkParams.capabilities)
 	addSchemaFlags(checkCommand.Flags(), checkParams.schema)
 	addStrictFlag(checkCommand.Flags(), &checkParams.strict, false)
-	// FIXME: Rename or add new flag with same effect? '--rego-v1' will become even more confusing in 1.0, as what it actually means is check that module is compatible with BOTH v0 and v1.
-	addRegoV1FlagWithDescription(checkCommand.Flags(), &checkParams.regoV1, false,
-		"check for Rego v1 compatibility (policies must also be compatible with current OPA version)")
+	addRegoV0V1FlagWithDescription(checkCommand.Flags(), &checkParams.regoV1, false,
+		"check for Rego v0 and v1 compatibility (policies must be compatible with both Rego versions)")
 	addV0CompatibleFlag(checkCommand.Flags(), &checkParams.v0Compatible, false)
 	addV1CompatibleFlag(checkCommand.Flags(), &checkParams.v1Compatible, false)
 	RootCommand.AddCommand(checkCommand)

cmd/flags.go

@@ -153,8 +153,12 @@ func addStrictFlag(fs *pflag.FlagSet, strict *bool, value bool) {
 	fs.BoolVarP(strict, "strict", "S", value, "enable compiler strict mode")
 }
 
-func addRegoV1FlagWithDescription(fs *pflag.FlagSet, regoV1 *bool, value bool, description string) {
+func addRegoV0V1FlagWithDescription(fs *pflag.FlagSet, regoV1 *bool, value bool, description string) {
+	fs.BoolVar(regoV1, "v0-v1", value, description)
+
+	// For backwards compatibility
 	fs.BoolVar(regoV1, "rego-v1", value, description)
+	_ = fs.MarkHidden("rego-v1")
 }
 
 func addV0CompatibleFlag(fs *pflag.FlagSet, v1Compatible *bool, value bool) {

cmd/fmt.go

@@ -59,7 +59,7 @@ is provided - this tool will use stdin.
 The format of the output is not defined specifically; whatever this tool outputs
 is considered correct format (with the exception of bugs).
 
-If the '-w' option is supplied, the 'fmt' command with overwrite the source file
+If the '-w' option is supplied, the 'fmt' command will overwrite the source file
 instead of printing to stdout.
 
 If the '-d' option is supplied, the 'fmt' command will output a diff between the
@@ -70,7 +70,26 @@ that would change if formatted. The '-l' option will suppress any other output
 to stdout from the 'fmt' command.
 
 If the '--fail' option is supplied, the 'fmt' command will return a non zero exit
-code if a file would be reformatted.`,
+code if a file would be reformatted.
+
+The 'fmt' command can be run in several compatibility modes for consuming and outputting
+different Rego versions:
+
+* 'opa fmt':
+  * v1 Rego is formatted to v1
+  * 'rego.v1'/'future.keywords' imports are NOT removed
+  * 'rego.v1'/'future.keywords' imports are NOT added if missing
+  * v0 rego is rejected
+* 'opa fmt --v0-compatible':
+  * v0 Rego is formatted to v0
+  * v1 Rego is rejected
+* 'opa fmt --v0-v1':
+  * v0 Rego is formatted to be compatible with v0 AND v1
+  * v1 Rego is rejected
+* 'opa fmt --v0-v1 --v1-compatible':
+  * v1 Rego is formatted to be compatible with v0 AND v1
+  * v0 Rego is rejected
+`,
 	PreRunE: func(cmd *cobra.Command, _ []string) error {
 		return env.CmdFlags.CheckEnvironmentVariables(cmd)
 	},
@@ -138,6 +157,10 @@ func formatFile(params *fmtCommandParams, out io.Writer, filename string, info o
 		DropV0Imports: params.dropV0Imports,
 	}
 
+	if params.regoV1 {
+		opts.ParserOptions = &ast.ParserOptions{RegoVersion: ast.RegoV0}
+	}
+
 	if params.v0Compatible {
 		// v0 takes precedence over v1
 		opts.ParserOptions = &ast.ParserOptions{RegoVersion: ast.RegoV0}
@@ -216,6 +239,11 @@ func formatStdin(params *fmtCommandParams, r io.Reader, w io.Writer) error {
 
 	opts := format.Opts{}
 	opts.RegoVersion = params.regoVersion()
+
+	if params.regoV1 {
+		opts.ParserOptions = &ast.ParserOptions{RegoVersion: ast.RegoV0}
+	}
+
 	formatted, err := format.SourceWithOpts("stdin", contents, opts)
 	if err != nil {
 		return err
@@ -252,7 +280,7 @@ func init() {
 	formatCommand.Flags().BoolVarP(&fmtParams.list, "list", "l", false, "list all files who would change when formatted")
 	formatCommand.Flags().BoolVarP(&fmtParams.diff, "diff", "d", false, "only display a diff of the changes")
 	formatCommand.Flags().BoolVar(&fmtParams.fail, "fail", false, "non zero exit code on reformat")
-	addRegoV1FlagWithDescription(formatCommand.Flags(), &fmtParams.regoV1, false, "format module(s) to be compatible with both Rego v1 and current OPA version)")
+	addRegoV0V1FlagWithDescription(formatCommand.Flags(), &fmtParams.regoV1, false, "format module(s) to be compatible with both Rego v0 and v1")
 	addV0CompatibleFlag(formatCommand.Flags(), &fmtParams.v0Compatible, false)
 	addV1CompatibleFlag(formatCommand.Flags(), &fmtParams.v1Compatible, false)
 	formatCommand.Flags().BoolVar(&fmtParams.checkResult, "check-result", true, "assert that the formatted code is valid and can be successfully parsed (default true)")

cmd/fmt_test.go

@@ -746,10 +746,11 @@ func TestFmtMultipleWrongArityError(t *testing.T) {
 
 func TestFmtRegoV1(t *testing.T) {
 	tests := []struct {
-		note        string
-		input       string
-		expected    string
-		expectedErr string
+		note         string
+		v1Compatible bool
+		input        string
+		expected     string
+		expectedErr  string
 	}{
 		{
 			note: "no future imports",
@@ -835,14 +836,30 @@ q := all([true, false])
 %ROOT%/policy.rego:3: rego_type_error: deprecated built-in function calls in expression: any
 %ROOT%/policy.rego:6: rego_type_error: deprecated built-in function calls in expression: all`,
 		},
+		{
+			note:         "v1 module",
+			v1Compatible: true,
+			input: `package test
+
+p contains x if {
+	some x in ["a", "b", "c"]
+}`,
+			expected: `package test
+
+import rego.v1
+
+p contains x if {
+	some x in ["a", "b", "c"]
+}
+`,
+		},
 	}
 
 	for _, tc := range tests {
 		t.Run(tc.note, func(t *testing.T) {
 			params := fmtCommandParams{
-				// Locking rego-version to v0, as it's only then the --rego-v1 flag is relevant
-				v0Compatible: true,
 				regoV1:       true,
+				v1Compatible: tc.v1Compatible,
 			}
 
 			files := map[string]string{