Fix some issues with whitespace in formatter.

mojom/mojom_parser/formatter/printer.go

 // Copyright 2016 The Chromium 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 formatter
 
 import (
         "bytes"
         "fmt"
         "mojom/mojom_parser/lexer"
@@ skipping 78 matching lines @@
         if len(mojomFile.Imports) > 0 {
                 p.writeImportedFiles(mojomFile.Imports)
         }
 
         for _, declaredObject := range mojomFile.DeclaredObjects {
                 p.writeDeclaredObject(declaredObject)
                 p.nl()
         }
 
         if mojomFile.FinalComments != nil {
-                finalComments := trimEmptyLines(mojomFile.FinalComments)
+                finalComments := trimEmptyLinesEnd(mojomFile.FinalComments)
                 if len(finalComments) > 0 {
                         p.nl()
                         p.writeCommentBlocks(finalComments, true)
                 }
         }
 
         p.eofNoFormat()
 }
 
 // writeModuleNamespace writes a mojom file's module statement and associated
@@ skipping 258 matching lines @@
         p.writef("%v {", container.(mojom.DeclaredObject).NameToken().Text)
         if len(container.GetDeclaredObjects()) == 0 && !containsFinalComments(container.(mojom.MojomElement)) {
                 p.writef("};")
                 return
         }
         p.writeRightComments(container.(mojom.MojomElement))
         p.incIndent()
         p.nl()
         declaredObjects := container.GetDeclaredObjects()
         for i, declaredObject := range declaredObjects {
+                if i == 0 {
+                        trimEmptyLinesDeclaredObject(declaredObject)
+                }
                 p.writeDeclaredObject(declaredObject)
                 if i < len(declaredObjects)-1 {
                         p.nl()
                 }
         }
 
         // Write the comments at the end of the struct, enum, union or interface body.
         p.writeFinalComments(container)
 
         p.decIndent()
@@ skipping 237 matching lines @@
 // line is written after all the comments are written.
 func (p *printer) writeCommentBlocks(comments []lexer.Token, finalEol bool) {
         for i, comment := range comments {
                 switch comment.Kind {
                 case lexer.SingleLineComment:
                         if comment.Text == "// no-format" {
                                 p.startNoFormat(comment)
                         } else if comment.Text == "// end-no-format" {
                                 p.endNoFormat(comment)
                         }
-                        p.write(comment.Text)
+                        p.writeSingleLineComment(comment)
                         if finalEol || i < len(comments)-1 {
                                 p.nl()
                         }
                 case lexer.MultiLineComment:
                         p.writeMultiLineComment(comment)
                         if finalEol || i < len(comments)-1 {
                                 p.nl()
                         }
                 case lexer.EmptyLine:
                         // We only use EmptyLine here to separate comment blocks. And we collapse
                         // sequences of empty lines to a single empty line.
                         if i != 0 && comments[i-1].Kind != lexer.EmptyLine {
                                 p.nl()
                         }
                 default:
                         panic(fmt.Sprintf("%s is not a comment.", comment))
                 }
         }
 }
 
+func (p *printer) writeSingleLineComment(comment lexer.Token) {
+        if comment.Kind != lexer.SingleLineComment {
+                panic(fmt.Sprintf("This is not a SingleLineComment: %s", comment))
+        }
+        commentText := comment.Text
+
+        // We expect that the first 2 characters are // followed by a space or tab.
+        // If the third character is not a space or tab, we insert a space.
+        space := commentText[2]
+        if space != ' ' && space != '\t' {
+                commentText = "// " + commentText[2:]
+        }
+        p.write(commentText)
+}
+
 func (p *printer) writeMultiLineComment(comment lexer.Token) {
         if comment.Kind != lexer.MultiLineComment {
                 panic(fmt.Sprintf("This is not a MultiLineComment: %s", comment))
         }
 
         lines := strings.Split(comment.Text, "\n")
         for i, line := range lines {
                 trimmed := strings.Trim(line, " \t")
                 // If a line starts with * we assume the user is trying to use the pattern
                 // whereby they align the comment with spaces after the *. Otherwise,
@@ skipping 61 matching lines @@
                 p.buffer.WriteString(s)
         }
 }
 
 // nl writes a new line. Before writing the new line, nl writes the last
 // comment on the line.
 func (p *printer) nl() {
         // Before going to the next line, print the last comment on the line.
         if p.eolComment != nil {
                 if !p.noFormat {
-                        p.writef("  %s", p.eolComment.Text)
+                        p.write("  ")
+                        p.writeSingleLineComment(*p.eolComment)
                 }
                 p.eolComment = nil
         }
 
         if !p.noFormat {
                 p.buffer.WriteString("\n")
         }
         p.linePos = 0
 }
 
@@ skipping 113 matching lines @@
         }
 
         for _, comment := range attachedComments.Final {
                 if comment.Kind != lexer.EmptyLine {
                         return true
                 }
         }
         return false
 }
 
-// trimEmptyLines trims out empty line comments at the end of a slice of comments.
-func trimEmptyLines(comments []lexer.Token) []lexer.Token {
+// trimEmptyLinesEnd trims out empty line comments at the end of a slice of comments.
+func trimEmptyLinesEnd(comments []lexer.Token) []lexer.Token {
         lastNonEmpty := -1
         for i, comment := range comments {
                 if comment.Kind != lexer.EmptyLine {
                         lastNonEmpty = i
                 }
         }
         return comments[:lastNonEmpty+1]
 }
 
+// trimEmptyLinesBegin trims out empty line comments at the beginning of a slice of comments.
+func trimEmptyLinesBegin(comments []lexer.Token) []lexer.Token {
+        for i, comment := range comments {
+                if comment.Kind != lexer.EmptyLine {
+                        return comments[i:]
+                }
+        }
+        return comments[len(comments):]
+}
+
+// trimEmptyLinesDeclaredObject trims out empty lines from the beginning of the
+// comments on a DeclaredObject or its Attributes.
+func trimEmptyLinesDeclaredObject(declaredObject mojom.DeclaredObject) {
+        if declaredObject.Attributes() != nil {
+                comments := declaredObject.Attributes().AttachedComments()
+                if comments == nil {
+                        return
+                }
+                comments.Above = trimEmptyLinesBegin(comments.Above)
+                return
+        }
+        comments := declaredObject.AttachedComments()
+
+        if comments == nil || len(comments.Above) == 0 {
+                return
+        }
+        comments.Above = trimEmptyLinesBegin(comments.Above)
+}
+
 // Following is a utility to sort slices of |ImportedFile|s.
 
 // sortImportedFiles sorts the slice of imported files it receives.
 func sortImportedFiles(imports []*mojom.ImportedFile) {
         sort.Sort(&importedFilesSorter{imports})
 }
 
 type importedFilesSorter struct {
         imports []*mojom.ImportedFile
 }
 
 // See sort.Interface.
 func (ifs *importedFilesSorter) Len() int {
         return len(ifs.imports)
 }
 
 // See sort.Interface.
 func (ifs *importedFilesSorter) Less(i, j int) bool {
         return ifs.imports[i].SpecifiedName < ifs.imports[j].SpecifiedName
 }
 
 // See sort.Interface.
 func (ifs *importedFilesSorter) Swap(i, j int) {
         ifs.imports[i], ifs.imports[j] = ifs.imports[j], ifs.imports[i]
 }