code review 174051: New flags for gofmt:

src/cmd/gofmt/gofmt.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package main
 
 import (
         "bytes";
         oldParser "exp/parser";
         "flag";
@@ skipping 18 matching lines @@
         // debugging support
         comments        = flag.Bool("comments", true, "print comments");
         trace           = flag.Bool("trace", false, "print parse trace");
 
         // layout control
         tabWidth        = flag.Int("tabwidth", 8, "tab width");
         tabIndent       = flag.Bool("tabindent", false, "indent with tabs independent of -spaces");
         useSpaces       = flag.Bool("spaces", false, "align with spaces instead of tabs");
 
         // semicolon transition
-        insertSemis             = flag.Bool("insertsemis", false, "accept automatically inserted semicolons");

[rsc, 2009/12/10 23:53:33]

It's not clear to me (just looking at the name) whether
the semis are inserted on input or output.  printNoSemis
seems ambiguous in a different way, since printNoSemis=false
still doesn't print as many semicolons as possible.

Maybe these flags should be

useOldParser = flag.Bool("oldparser", true, "parse old (required semicolons)
syntax");
useOldPrinter = flag.Bool("oldprinter", true, "print old (required semicolons)
syntax");

Can printNoStringConcat be dropped entirely?  Now that the tree
doesn't use string concatenation anymore, it seems okay for the
default (and only) behavior to be to insert the +.

-        printNoSemis            = flag.Bool("printnosemis", false, "don't print semicolons that can be left away");
-        printNoStringConcat     = flag.Bool("printnostringconcat", false, "don't print string lists without '+'");
+        useOldParser    = flag.Bool("oldparser", true, "parse old syntax (required semicolons)");
+        useOldPrinter   = flag.Bool("oldprinter", true, "print old syntax (required semicolons)");
 )
 
 
 var (
         exitCode        = 0;
         rewrite         func(*ast.File) *ast.File;
         parserMode      uint;
         printerMode     uint;
 )
 
@@ skipping 16 matching lines @@
         if *comments {
                 parserMode |= parser.ParseComments
         }
         if *trace {
                 parserMode |= parser.Trace
         }
 }
 
 
 func initPrinterMode() {
-        printerMode = uint(0);
+        printerMode = printer.NoStringConcat;
         if *tabIndent {
                 printerMode |= printer.TabIndent
         }
         if *useSpaces {
                 printerMode |= printer.UseSpaces
         }
-        if *printNoSemis {
+        if !*useOldPrinter {
                 printerMode |= printer.NoSemis
-        }
-        if *printNoStringConcat {
-                printerMode |= printer.NoStringConcat
         }
 }
 
 
 func isGoFile(d *os.Dir) bool {
         // ignore non-Go files
         return d.IsRegular() && !strings.HasPrefix(d.Name, ".") && strings.HasSuffix(d.Name, ".go")
 }
 
 
 func processFile(f *os.File) os.Error {
         src, err := ioutil.ReadAll(f);
         if err != nil {
                 return err
         }
 
         var file *ast.File;
-        if *insertSemis {
+        if *useOldParser {
+                file, err = oldParser.ParseFile(f.Name(), src, parserMode)
+        } else {
                 file, err = parser.ParseFile(f.Name(), src, parserMode)
-        } else {
-                file, err = oldParser.ParseFile(f.Name(), src, parserMode)
         }
         if err != nil {
                 return err
         }
 
         if rewrite != nil {
                 file = rewrite(file)
         }
 
         var res bytes.Buffer;
@@ skipping 96 matching lines @@
                         if err := processFileByName(path); err != nil {
                                 report(err)
                         }
                 case dir.IsDirectory():
                         walkDir(path)
                 }
         }
 
         os.Exit(exitCode);
 }