Parse type annotations correctly

Author: guelfey

variant.go

@@ -23,8 +23,8 @@ func MakeVariant(v interface{}) Variant {
 // https://developer.gnome.org/glib/unstable/gvariant-text.html. If sig is not
 // empty, it is taken to be the expected signature for the variant.
 func ParseVariant(s string, sig Signature) (Variant, error) {
-	ch := varLex(s)
-	p := &varParser{ch: ch}
+	tokens := varLex(s)
+	p := &varParser{tokens: tokens}
 	n, err := varMakeNode(p)
 	if err != nil {
 		return Variant{}, err

variant_lexer.go

@@ -39,14 +39,14 @@ type varLexer struct {
 	start  int
 	pos    int
 	width  int
-	tokens chan varToken
+	tokens []varToken
 }
 
 type lexState func(*varLexer) lexState
 
-func varLex(s string) chan varToken {
-	l := &varLexer{input: s, tokens: make(chan varToken)}
-	go l.run()
+func varLex(s string) []varToken {
+	l := &varLexer{input: s}
+	l.run()
 	return l.tokens
 }
 
@@ -63,15 +63,15 @@ func (l *varLexer) backup() {
 }
 
 func (l *varLexer) emit(t varTokenType) {
-	l.tokens <- varToken{t, l.input[l.start:l.pos]}
+	l.tokens = append(l.tokens, varToken{t, l.input[l.start:l.pos]})
 	l.start = l.pos
 }
 
 func (l *varLexer) errorf(format string, v ...interface{}) lexState {
-	l.tokens <- varToken{
+	l.tokens = append(l.tokens, varToken{
 		tokError,
 		fmt.Sprintf(format, v...),
-	}
+	})
 	return nil
 }
 
@@ -95,7 +95,6 @@ func (l *varLexer) run() {
 	for state := varLexNormal; state != nil; {
 		state = state(l)
 	}
-	close(l.tokens)
 }
 
 func (l *varLexer) peek() rune {
@@ -133,6 +132,11 @@ func varLexNormal(l *varLexer) lexState {
 		case r == '@':
 			l.backup()
 			return varLexType
+		case unicode.IsSpace(r):
+			l.ignore()
+		case unicode.IsNumber(r) || r == '+' || r == '-':
+			l.backup()
+			return varLexNumber
 		case r == 'b':
 			pos := l.start
 			if n := l.peek(); n == '"' || n == '\'' {
@@ -141,28 +145,25 @@ func varLexNormal(l *varLexer) lexState {
 			// not a byte string; try to parse it as a type or bool below
 			l.pos = pos + 1
 			l.width = 1
-		case unicode.IsSpace(r):
-			l.ignore()
-		case unicode.IsNumber(r) || r == '+' || r == '-':
-			l.backup()
-			return varLexNumber
+			fallthrough
 		default:
 			// either a bool or a type. Try bools first.
 			l.backup()
 			if l.pos+4 <= len(l.input) {
 				if l.input[l.pos:l.pos+4] == "true" {
 					l.pos += 4
 					l.emit(tokBool)
+					continue
 				}
 			} else if l.pos+5 <= len(l.input) {
 				if l.input[l.pos:l.pos+5] == "false" {
 					l.pos += 5
 					l.emit(tokBool)
+					continue
 				}
-			} else {
-				// must be a type.
-				return varLexType
 			}
+			// must be a type.
+			return varLexType
 		}
 	}
 }

variant_parser.go

@@ -12,21 +12,21 @@ import (
 )
 
 type varParser struct {
-	ch    chan varToken
-	saved varToken
+	tokens []varToken
+	i      int
 }
 
-func (p *varParser) backup(t varToken) {
-	p.saved = t
+func (p *varParser) backup() {
+	p.i--
 }
 
 func (p *varParser) next() varToken {
-	if p.saved.typ != tokEOF {
-		t := p.saved
-		p.saved = varToken{}
+	if p.i < len(p.tokens) {
+		t := p.tokens[p.i]
+		p.i++
 		return t
 	}
-	return <-p.ch
+	return varToken{typ: tokEOF}
 }
 
 type varNode interface {
@@ -471,7 +471,7 @@ func varMakeArrayNode(p *varParser, sig Signature) (varNode, error) {
 	if t := p.next(); t.typ == tokArrayEnd {
 		return n, nil
 	} else {
-		p.backup(t)
+		p.backup()
 	}
 Loop:
 	for {
@@ -482,7 +482,7 @@ Loop:
 		case tokError:
 			return nil, errors.New(t.val)
 		}
-		p.backup(t)
+		p.backup()
 		cn, err := varMakeNode(p)
 		if err != nil {
 			return nil, err
@@ -653,7 +653,7 @@ func varMakeDictNode(p *varParser, sig Signature) (varNode, error) {
 	if t := p.next(); t.typ == tokDictEnd {
 		return n, nil
 	} else {
-		p.backup(t)
+		p.backup()
 	}
 Loop:
 	for {
@@ -664,7 +664,7 @@ Loop:
 		case tokError:
 			return nil, errors.New(t.val)
 		}
-		p.backup(t)
+		p.backup()
 		kn, err := varMakeNode(p)
 		if err != nil {
 			return nil, err
@@ -696,7 +696,7 @@ Loop:
 		case tokError:
 			return nil, errors.New(t.val)
 		}
-		p.backup(t)
+		p.backup()
 		vn, err := varMakeNode(p)
 		if err != nil {
 			return nil, err

variant_test.go

@@ -54,6 +54,8 @@ var variantParseTests = []struct {
 	{`b"abc"`, []byte{'a', 'b', 'c', 0}},
 	{`b"\x01\0002\n"`, []byte{1, 2, '\n', 0}},
 	{`[[0], b""]`, [][]byte{{0}, {0}}},
+	{"int16 0", int16(0)},
+	{"byte 0", byte(0)},
 }
 
 func TestParseVariant(t *testing.T) {