code review 6225047: go/scanner: strip carriage returns from commments

src/pkg/go/scanner/scanner.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 scanner implements a scanner for Go source text.
 // It takes a []byte as source which can then be tokenized
 // through repeated calls to the Scan method.
 //
 package scanner
 
@@ skipping 139 matching lines @@
                                 // update scanner position
                                 s.file.AddLineInfo(s.lineOffset+len(text)+1, filename, line) // +len(text)+1 since comment applies to next line
                         }
                 }
         }
 }
 
 func (s *Scanner) scanComment() string {
         // initial '/' already consumed; s.ch == '/' || s.ch == '*'
         offs := s.offset - 1 // position of initial '/'
+        hasCR := false
 
         if s.ch == '/' {
                 //-style comment
                 s.next()
                 for s.ch != '\n' && s.ch >= 0 {
+                        if s.ch == '\r' {
+                                hasCR = true
+                        }
                         s.next()
                 }
                 if offs == s.lineOffset {
                         // comment starts at the beginning of the current line
                         s.interpretLineComment(s.src[offs:s.offset])
                 }
                 goto exit
         }
 
         /*-style comment */
         s.next()
         for s.ch >= 0 {
                 ch := s.ch
+                if ch == '\r' {
+                        hasCR = true
+                }
                 s.next()
                 if ch == '*' && s.ch == '/' {
                         s.next()
                         goto exit
                 }
         }
 
         s.error(offs, "comment not terminated")
 
 exit:
-        return string(s.src[offs:s.offset])
+        lit := s.src[offs:s.offset]
+        if hasCR {
+                lit = stripCR(lit)
+        }
+
+        return string(lit)
 }
 
 func (s *Scanner) findLineEnd() bool {
         // initial '/' already consumed
 
         defer func(offs int) {
                 // reset scanner state to where it was upon calling findLineEnd
                 s.ch = '/'
                 s.offset = offs
                 s.rdOffset = offs + 1
@@ skipping 321 matching lines @@
 }
 
 // Scan scans the next token and returns the token position, the token,
 // and its literal string if applicable. The source end is indicated by
 // token.EOF.
 //
 // If the returned token is a literal (token.IDENT, token.INT, token.FLOAT,
 // token.IMAG, token.CHAR, token.STRING) or token.COMMENT, the literal string
 // has the corresponding value.
 //
+// If the returned token is a keyword, the literal string is the keyword.
+//
 // If the returned token is token.SEMICOLON, the corresponding
 // literal string is ";" if the semicolon was present in the source,
 // and "\n" if the semicolon was inserted because of a newline or
 // at EOF.
 //
 // If the returned token is token.ILLEGAL, the literal string is the
 // offending character.
 //
 // In all other cases, Scan returns an empty literal string.
 //
@@ skipping 155 matching lines @@
                         tok = token.ILLEGAL
                         lit = string(ch)
                 }
         }
         if s.mode&dontInsertSemis == 0 {
                 s.insertSemi = insertSemi
         }
 
         return
 }