Update dependencies

- uses newer version of go-ethereum required for go1.11

vendor/github.com/hashicorp/hcl/go.mod

@@ -0,0 +1,3 @@
+module github.com/hashicorp/hcl
+
+require github.com/davecgh/go-spew v1.1.1

vendor/github.com/hashicorp/hcl/go.sum

@@ -0,0 +1,2 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

vendor/github.com/hashicorp/hcl/hcl/ast/ast_test.go

@@ -137,7 +137,7 @@ func TestWalkEquality(t *testing.T) {
 	}
 
 	if len(newNode.Items) != 2 {
-		t.Error("expected newNode length 2, got: %d", len(newNode.Items))
+		t.Errorf("expected newNode length 2, got: %d", len(newNode.Items))
 	}
 
 	expected := []string{
@@ -147,7 +147,7 @@ func TestWalkEquality(t *testing.T) {
 
 	for i, item := range newNode.Items {
 		if len(item.Keys) != 1 {
-			t.Error("expected keys newNode length 1, got: %d", len(item.Keys))
+			t.Errorf("expected keys newNode length 1, got: %d", len(item.Keys))
 		}
 
 		if item.Keys[0].Token.Text != expected[i] {

vendor/github.com/hashicorp/hcl/hcl/fmtcmd/fmtcmd_test.go

@@ -46,7 +46,7 @@ func TestIsValidFile(t *testing.T) {
 		}
 
 		if res := isValidFile(file, fixtureExtensions); res != tc.Expected {
-			t.Errorf("want: %b, got: %b", tc.Expected, res)
+			t.Errorf("want: %t, got: %t", tc.Expected, res)
 		}
 	}
 }
@@ -86,7 +86,7 @@ func TestRunMultiplePaths(t *testing.T) {
 		t.Errorf("unexpected error: %s", err)
 	}
 	if stdout.String() != expectedOut.String() {
-		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut, stdout)
+		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut.String(), stdout.String())
 	}
 }
 
@@ -132,7 +132,7 @@ func TestRunSubDirectories(t *testing.T) {
 		t.Errorf("unexpected error: %s", err)
 	}
 	if stdout.String() != expectedOut.String() {
-		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut, stdout)
+		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut.String(), stdout.String())
 	}
 }
 
@@ -161,7 +161,7 @@ func TestRunStdin(t *testing.T) {
 		t.Errorf("unexpected error: %s", err)
 	}
 	if !bytes.Equal(stdout.Bytes(), expectedOut.Bytes()) {
-		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut, stdout)
+		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut.String(), stdout.String())
 	}
 }
 
@@ -242,7 +242,7 @@ func TestRunNoOptions(t *testing.T) {
 		t.Errorf("unexpected error: %s", err)
 	}
 	if stdout.String() != expectedOut.String() {
-		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut, stdout)
+		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut.String(), stdout.String())
 	}
 }
 
@@ -274,7 +274,7 @@ func TestRunList(t *testing.T) {
 		t.Errorf("unexpected error: %s", err)
 	}
 	if stdout.String() != expectedOut.String() {
-		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut, stdout)
+		t.Errorf("stdout want:\n%s\ngot:\n%s", expectedOut.String(), stdout.String())
 	}
 }
 

vendor/github.com/hashicorp/hcl/hcl/parser/parser.go

@@ -205,6 +205,12 @@ func (p *Parser) objectItem() (*ast.ObjectItem, error) {
 		}
 	}
 
+	// key=#comment
+	// val
+	if p.lineComment != nil {
+		o.LineComment, p.lineComment = p.lineComment, nil
+	}
+
 	// do a look-ahead for line comment
 	p.scan()
 	if len(keys) > 0 && o.Val.Pos().Line == keys[0].Pos().Line && p.lineComment != nil {

vendor/github.com/hashicorp/hcl/hcl/printer/nodes.go

@@ -252,6 +252,14 @@ func (p *printer) objectItem(o *ast.ObjectItem) []byte {
 		}
 	}
 
+	// If key and val are on different lines, treat line comments like lead comments.
+	if o.LineComment != nil && o.Val.Pos().Line != o.Keys[0].Pos().Line {
+		for _, comment := range o.LineComment.List {
+			buf.WriteString(comment.Text)
+			buf.WriteByte(newline)
+		}
+	}
+
 	for i, k := range o.Keys {
 		buf.WriteString(k.Token.Text)
 		buf.WriteByte(blank)
@@ -265,7 +273,7 @@ func (p *printer) objectItem(o *ast.ObjectItem) []byte {
 
 	buf.Write(p.output(o.Val))
 
-	if o.Val.Pos().Line == o.Keys[0].Pos().Line && o.LineComment != nil {
+	if o.LineComment != nil && o.Val.Pos().Line == o.Keys[0].Pos().Line {
 		buf.WriteByte(blank)
 		for _, comment := range o.LineComment.List {
 			buf.WriteString(comment.Text)
@@ -509,8 +517,13 @@ func (p *printer) alignedItems(items []*ast.ObjectItem) []byte {
 
 // list returns the printable HCL form of an list type.
 func (p *printer) list(l *ast.ListType) []byte {
+	if p.isSingleLineList(l) {
+		return p.singleLineList(l)
+	}
+
 	var buf bytes.Buffer
 	buf.WriteString("[")
+	buf.WriteByte(newline)
 
 	var longestLine int
 	for _, item := range l.List {
@@ -523,115 +536,112 @@ func (p *printer) list(l *ast.ListType) []byte {
 		}
 	}
 
-	insertSpaceBeforeItem := false
-	lastHadLeadComment := false
+	haveEmptyLine := false
 	for i, item := range l.List {
-		// Keep track of whether this item is a heredoc since that has
-		// unique behavior.
-		heredoc := false
+		// If we have a lead comment, then we want to write that first
+		leadComment := false
+		if lit, ok := item.(*ast.LiteralType); ok && lit.LeadComment != nil {
+			leadComment = true
+
+			// Ensure an empty line before every element with a
+			// lead comment (except the first item in a list).
+			if !haveEmptyLine && i != 0 {
+				buf.WriteByte(newline)
+			}
+
+			for _, comment := range lit.LeadComment.List {
+				buf.Write(p.indent([]byte(comment.Text)))
+				buf.WriteByte(newline)
+			}
+		}
+
+		// also indent each line
+		val := p.output(item)
+		curLen := len(val)
+		buf.Write(p.indent(val))
+
+		// if this item is a heredoc, then we output the comma on
+		// the next line. This is the only case this happens.
+		comma := []byte{','}
 		if lit, ok := item.(*ast.LiteralType); ok && lit.Token.Type == token.HEREDOC {
-			heredoc = true
-		}
-
-		if item.Pos().Line != l.Lbrack.Line {
-			// multiline list, add newline before we add each item
 			buf.WriteByte(newline)
-			insertSpaceBeforeItem = false
+			comma = p.indent(comma)
+		}
 
-			// If we have a lead comment, then we want to write that first
-			leadComment := false
-			if lit, ok := item.(*ast.LiteralType); ok && lit.LeadComment != nil {
-				leadComment = true
+		buf.Write(comma)
 
-				// If this isn't the first item and the previous element
-				// didn't have a lead comment, then we need to add an extra
-				// newline to properly space things out. If it did have a
-				// lead comment previously then this would be done
-				// automatically.
-				if i > 0 && !lastHadLeadComment {
-					buf.WriteByte(newline)
-				}
-
-				for _, comment := range lit.LeadComment.List {
-					buf.Write(p.indent([]byte(comment.Text)))
-					buf.WriteByte(newline)
-				}
-			}
-
-			// also indent each line
-			val := p.output(item)
-			curLen := len(val)
-			buf.Write(p.indent(val))
-
-			// if this item is a heredoc, then we output the comma on
-			// the next line. This is the only case this happens.
-			comma := []byte{','}
-			if heredoc {
-				buf.WriteByte(newline)
-				comma = p.indent(comma)
-			}
-
-			buf.Write(comma)
-
-			if lit, ok := item.(*ast.LiteralType); ok && lit.LineComment != nil {
-				// if the next item doesn't have any comments, do not align
-				buf.WriteByte(blank) // align one space
-				for i := 0; i < longestLine-curLen; i++ {
-					buf.WriteByte(blank)
-				}
-
-				for _, comment := range lit.LineComment.List {
-					buf.WriteString(comment.Text)
-				}
-			}
-
-			lastItem := i == len(l.List)-1
-			if lastItem {
-				buf.WriteByte(newline)
-			}
-
-			if leadComment && !lastItem {
-				buf.WriteByte(newline)
-			}
-
-			lastHadLeadComment = leadComment
-		} else {
-			if insertSpaceBeforeItem {
+		if lit, ok := item.(*ast.LiteralType); ok && lit.LineComment != nil {
+			// if the next item doesn't have any comments, do not align
+			buf.WriteByte(blank) // align one space
+			for i := 0; i < longestLine-curLen; i++ {
 				buf.WriteByte(blank)
-				insertSpaceBeforeItem = false
 			}
 
-			// Output the item itself
-			// also indent each line
-			val := p.output(item)
-			curLen := len(val)
-			buf.Write(val)
-
-			// If this is a heredoc item we always have to output a newline
-			// so that it parses properly.
-			if heredoc {
-				buf.WriteByte(newline)
-			}
-
-			// If this isn't the last element, write a comma.
-			if i != len(l.List)-1 {
-				buf.WriteString(",")
-				insertSpaceBeforeItem = true
-			}
-
-			if lit, ok := item.(*ast.LiteralType); ok && lit.LineComment != nil {
-				// if the next item doesn't have any comments, do not align
-				buf.WriteByte(blank) // align one space
-				for i := 0; i < longestLine-curLen; i++ {
-					buf.WriteByte(blank)
-				}
-
-				for _, comment := range lit.LineComment.List {
-					buf.WriteString(comment.Text)
-				}
+			for _, comment := range lit.LineComment.List {
+				buf.WriteString(comment.Text)
 			}
 		}
 
+		buf.WriteByte(newline)
+
+		// Ensure an empty line after every element with a
+		// lead comment (except the first item in a list).
+		haveEmptyLine = leadComment && i != len(l.List)-1
+		if haveEmptyLine {
+			buf.WriteByte(newline)
+		}
+	}
+
+	buf.WriteString("]")
+	return buf.Bytes()
+}
+
+// isSingleLineList returns true if:
+// * they were previously formatted entirely on one line
+// * they consist entirely of literals
+// * there are either no heredoc strings or the list has exactly one element
+// * there are no line comments
+func (printer) isSingleLineList(l *ast.ListType) bool {
+	for _, item := range l.List {
+		if item.Pos().Line != l.Lbrack.Line {
+			return false
+		}
+
+		lit, ok := item.(*ast.LiteralType)
+		if !ok {
+			return false
+		}
+
+		if lit.Token.Type == token.HEREDOC && len(l.List) != 1 {
+			return false
+		}
+
+		if lit.LineComment != nil {
+			return false
+		}
+	}
+
+	return true
+}
+
+// singleLineList prints a simple single line list.
+// For a definition of "simple", see isSingleLineList above.
+func (p *printer) singleLineList(l *ast.ListType) []byte {
+	buf := &bytes.Buffer{}
+
+	buf.WriteString("[")
+	for i, item := range l.List {
+		if i != 0 {
+			buf.WriteString(", ")
+		}
+
+		// Output the item itself
+		buf.Write(p.output(item))
+
+		// The heredoc marker needs to be at the end of line.
+		if lit, ok := item.(*ast.LiteralType); ok && lit.Token.Type == token.HEREDOC {
+			buf.WriteByte(newline)
+		}
 	}
 
 	buf.WriteString("]")

vendor/github.com/hashicorp/hcl/hcl/printer/printer_test.go

@@ -147,3 +147,30 @@ func lineAt(text []byte, offs int) []byte {
 	}
 	return text[offs:i]
 }
+
+// TestFormatParsable ensures that the output of Format() is can be parsed again.
+func TestFormatValidOutput(t *testing.T) {
+	cases := []string{
+		"#\x00",
+		"#\ue123t",
+		"x=//\n0y=<<_\n_\n",
+		"y=[1,//\n]",
+		"Y=<<4\n4/\n\n\n/4/@=4/\n\n\n/4000000004\r\r\n00004\n",
+		"x=<<_\n_\r\r\n_\n",
+		"X=<<-\n\r\r\n",
+	}
+
+	for _, c := range cases {
+		f, err := Format([]byte(c))
+		if err != nil {
+			// ignore these failures, not all inputs are valid HCL.
+			t.Logf("Format(%q) = %v", c, err)
+			continue
+		}
+
+		if _, err := parser.Parse(f); err != nil {
+			t.Errorf("Format(%q) = %q; Parse(%q) = %v", c, f, f, err)
+			continue
+		}
+	}
+}

vendor/github.com/hashicorp/hcl/hcl/printer/testdata/comment.golden

@@ -34,3 +34,6 @@ variable = {
 foo {
   bar = "fatih" // line comment 2 
 } // line comment 3
+
+// comment
+multiline = "assignment"

vendor/github.com/hashicorp/hcl/hcl/printer/testdata/comment.input

@@ -35,3 +35,5 @@ foo {
     bar = "fatih"       // line comment 2 
 }        // line comment 3
 
+multiline = // comment
+"assignment"

vendor/github.com/hashicorp/hcl/hcl/printer/testdata/comment_crlf.input

@@ -35,3 +35,5 @@ foo {
     bar = "fatih"       // line comment 2 
 }        // line comment 3
 
+multiline = // comment
+"assignment"

vendor/github.com/hashicorp/hcl/hcl/printer/testdata/list.golden

@@ -2,11 +2,14 @@ foo = ["fatih", "arslan"]
 
 foo = ["bar", "qaz"]
 
-foo = ["zeynep",
+foo = [
+  "zeynep",
   "arslan",
 ]
 
-foo = ["fatih", "zeynep",
+foo = [
+  "fatih",
+  "zeynep",
   "arslan",
 ]
 

vendor/github.com/hashicorp/hcl/hcl/printer/testdata/list_comment.golden

@@ -1,7 +1,13 @@
-foo = [1, # Hello
+foo = [
+  1, # Hello
   2,
 ]
 
-foo = [1, # Hello
+foo = [
+  1, # Hello
   2, # World
 ]
+
+foo = [
+  1, # Hello
+]

vendor/github.com/hashicorp/hcl/hcl/printer/testdata/list_comment.input

@@ -4,3 +4,6 @@ foo = [1, # Hello
 foo = [1, # Hello
 2, # World
 ]
+
+foo = [1, # Hello
+]

vendor/github.com/hashicorp/hcl/hcl/printer/testdata/object_with_heredoc.golden

@@ -1,6 +1,7 @@
 obj {
   foo = [<<EOF
         TEXT!
+!!EOF
 EOF
   ]
 }

vendor/github.com/hashicorp/hcl/hcl/printer/testdata/object_with_heredoc.input

@@ -1,6 +1,7 @@
 obj {
     foo = [<<EOF
         TEXT!
+!!EOF
 EOF
     ]
 }

vendor/github.com/hashicorp/hcl/hcl/scanner/scanner.go

@@ -74,14 +74,6 @@ func (s *Scanner) next() rune {
 		return eof
 	}
 
-	if ch == utf8.RuneError && size == 1 {
-		s.srcPos.Column++
-		s.srcPos.Offset += size
-		s.lastCharLen = size
-		s.err("illegal UTF-8 encoding")
-		return ch
-	}
-
 	// remember last position
 	s.prevPos = s.srcPos
 
@@ -89,18 +81,27 @@ func (s *Scanner) next() rune {
 	s.lastCharLen = size
 	s.srcPos.Offset += size
 
+	if ch == utf8.RuneError && size == 1 {
+		s.err("illegal UTF-8 encoding")
+		return ch
+	}
+
 	if ch == '\n' {
 		s.srcPos.Line++
 		s.lastLineLen = s.srcPos.Column
 		s.srcPos.Column = 0
 	}
 
-	// If we see a null character with data left, then that is an error
-	if ch == '\x00' && s.buf.Len() > 0 {
+	if ch == '\x00' {
 		s.err("unexpected null character (0x00)")
 		return eof
 	}
 
+	if ch == '\uE123' {
+		s.err("unicode code point U+E123 reserved for internal use")
+		return utf8.RuneError
+	}
+
 	// debug
 	// fmt.Printf("ch: %q, offset:column: %d:%d\n", ch, s.srcPos.Offset, s.srcPos.Column)
 	return ch
@@ -432,16 +433,16 @@ func (s *Scanner) scanHeredoc() {
 
 	// Read the identifier
 	identBytes := s.src[offs : s.srcPos.Offset-s.lastCharLen]
-	if len(identBytes) == 0 {
+	if len(identBytes) == 0 || (len(identBytes) == 1 && identBytes[0] == '-') {
 		s.err("zero-length heredoc anchor")
 		return
 	}
 
 	var identRegexp *regexp.Regexp
 	if identBytes[0] == '-' {
-		identRegexp = regexp.MustCompile(fmt.Sprintf(`[[:space:]]*%s\z`, identBytes[1:]))
+		identRegexp = regexp.MustCompile(fmt.Sprintf(`^[[:space:]]*%s\r*\z`, identBytes[1:]))
 	} else {
-		identRegexp = regexp.MustCompile(fmt.Sprintf(`[[:space:]]*%s\z`, identBytes))
+		identRegexp = regexp.MustCompile(fmt.Sprintf(`^[[:space:]]*%s\r*\z`, identBytes))
 	}
 
 	// Read the actual string value
@@ -551,7 +552,7 @@ func (s *Scanner) scanDigits(ch rune, base, n int) rune {
 		s.err("illegal char escape")
 	}
 
-	if n != start {
+	if n != start && ch != eof {
 		// we scanned all digits, put the last non digit char back,
 		// only if we read anything at all
 		s.unread()

vendor/github.com/hashicorp/hcl/hcl/scanner/scanner_test.go

@@ -509,9 +509,12 @@ func TestScan_crlf(t *testing.T) {
 func TestError(t *testing.T) {
 	testError(t, "\x80", "1:1", "illegal UTF-8 encoding", token.ILLEGAL)
 	testError(t, "\xff", "1:1", "illegal UTF-8 encoding", token.ILLEGAL)
+	testError(t, "\uE123", "1:1", "unicode code point U+E123 reserved for internal use", token.ILLEGAL)
 
 	testError(t, "ab\x80", "1:3", "illegal UTF-8 encoding", token.IDENT)
 	testError(t, "abc\xff", "1:4", "illegal UTF-8 encoding", token.IDENT)
+	testError(t, "ab\x00", "1:3", "unexpected null character (0x00)", token.IDENT)
+	testError(t, "ab\x00\n", "1:3", "unexpected null character (0x00)", token.IDENT)
 
 	testError(t, `"ab`+"\x80", "1:4", "illegal UTF-8 encoding", token.STRING)
 	testError(t, `"abc`+"\xff", "1:5", "illegal UTF-8 encoding", token.STRING)
@@ -528,6 +531,9 @@ func TestError(t *testing.T) {
 	testError(t, `"${abc`+"\n", "2:1", "literal not terminated", token.STRING)
 	testError(t, `/*/`, "1:4", "comment not terminated", token.COMMENT)
 	testError(t, `/foo`, "1:1", "expected '/' for comment", token.COMMENT)
+
+	testError(t, "<<\nfoo\n\n", "1:3", "zero-length heredoc anchor", token.HEREDOC)
+	testError(t, "<<-\nfoo\n\n", "1:4", "zero-length heredoc anchor", token.HEREDOC)
 }
 
 func testError(t *testing.T, src, pos, msg string, tok token.Type) {
@@ -589,3 +595,48 @@ func countNewlines(s string) int {
 	}
 	return n
 }
+
+func TestScanDigitsUnread(t *testing.T) {
+	cases := []string{
+		"M=0\"\\00",
+		"M=\"\\00",
+		"\"\\00",
+		"M=[\"\\00",
+		"U{\"\\00",
+		"\"\n{}#\n\"\\00",
+		"M=[[\"\\00",
+		"U{d=0\"\\U00",
+		"#\n\"\\x00",
+		"m=[[[\"\\00",
+	}
+
+	for _, c := range cases {
+		s := New([]byte(c))
+
+		for {
+			tok := s.Scan()
+			if tok.Type == token.EOF {
+				break
+			}
+			t.Logf("s.Scan() = %s", tok)
+		}
+	}
+}
+
+func TestScanHeredocRegexpCompile(t *testing.T) {
+	cases := []string{
+		"0\xe1\n<<ȸ\nhello\nworld\nȸ",
+	}
+
+	for _, c := range cases {
+		s := New([]byte(c))
+
+		for {
+			tok := s.Scan()
+			if tok.Type == token.EOF {
+				break
+			}
+			t.Logf("s.Scan() = %s", tok)
+		}
+	}
+}