Basic go vet fixes.

Makefile

@@ -1,14 +1,20 @@
 gen:
-	go get github.com/clipperhouse/gen
-	go get github.com/clipperhouse/typewriter
-	go get github.com/clipperhouse/stringer
+	go get -u github.com/clipperhouse/gen
+	go get -u github.com/clipperhouse/typewriter
+	go get -u github.com/clipperhouse/stringer
 	go generate github.com/c9s/c6/...
 	go build github.com/c9s/c6/...
 	gen add github.com/c9s/c6/typewriter/symtable
 
-test: gen
+
+vet:
+	go vet github.com/c9s/c6/...
+
+
+test: gen vet 
 	go test github.com/c9s/c6/...
 
+
 benchupdatebase:
 	go test -run=NONE -bench=. github.com/c9s/c6/... >| benchmarks/old.txt
 

compiler/compact_compiler.go

@@ -94,7 +94,6 @@ func (compiler *CompactCompiler) CompileStmt(anyStm ast.Stmt) string {
 	case *ast.AssignStmt:
 	}
 	panic("Unsupported compilation")
-	return "fail"
 }
 
 func (compiler *CompactCompiler) CompileString(any interface{}) string {

lexer/lexer_state.go

@@ -3,8 +3,9 @@ package lexer
 import (
 	"errors"
 	"fmt"
-	"github.com/c9s/c6/ast"
 	"unicode"
+
+	"github.com/c9s/c6/ast"
 )
 
 type stateFn func(*Lexer) stateFn
@@ -599,7 +600,6 @@ func lexStmt(l *Lexer) stateFn {
 				break
 			} else if r == EOF {
 				panic("unexpected EOF")
-				break
 			}
 			r = l.next()
 		}

lexer/test_utils.go

@@ -66,7 +66,7 @@ func AssertTokenSequence(t *testing.T, l *Lexer, tokenList []ast.TokenType) []as
 		}
 	}
 	if failure {
-		t.Fatal()
+		t.Fatal("See log.")
 	}
 
 	return tokens

parser/rules.go

@@ -6,14 +6,15 @@ package parser
 
 import (
 	"fmt"
-	"github.com/c9s/c6/ast"
-	"github.com/c9s/c6/lexer"
-	"github.com/c9s/c6/runtime"
 	"os"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
+
+	"github.com/c9s/c6/ast"
+	"github.com/c9s/c6/lexer"
+	"github.com/c9s/c6/runtime"
 )
 
 var HttpUrlPattern = regexp.MustCompile("^https?://")
@@ -405,7 +406,6 @@ func (parser *Parser) ParseComplexSelector(parentRuleSet *ast.RuleSet) *ast.Comp
 
 		}
 	}
-	return complexSel
 }
 
 func (parser *Parser) ParseSelectorList() *ast.ComplexSelectorList {
@@ -1726,20 +1726,23 @@ func (parser *Parser) ParseIncludeStmt() ast.Stmt {
 func (parser *Parser) ParseFontFaceStmt() ast.Stmt {
 	parser.expect(ast.T_FONT_FACE)
 	block := parser.ParseDeclBlock()
-	return &ast.FontFaceStmt{block}
+	return &ast.FontFaceStmt{Block: block}
 }
 
 func (parser *Parser) ParseLogStmt() ast.Stmt {
 	if directiveTok := parser.acceptAnyOf3(ast.T_ERROR, ast.T_WARN, ast.T_INFO); directiveTok != nil {
 		var expr = parser.ParseExpr(false)
 		parser.expect(ast.T_SEMICOLON)
-		return &ast.LogStmt{directiveTok, expr}
+		return &ast.LogStmt{
+			Directive: directiveTok,
+			Expr:      expr,
+		}
+
 	}
 	panic(SyntaxError{
 		Reason:      "Expecting @error, @warn, @info directive",
 		ActualToken: parser.peek(),
 	})
-	return nil
 }
 
 /*

runtime/color.go

@@ -2,16 +2,23 @@ package runtime
 
 import (
 	"fmt"
-	"github.com/c9s/c6/ast"
 	"math"
+
+	"github.com/c9s/c6/ast"
 )
 
 func HexColorAddNumber(c *ast.HexColor, num *ast.Number) *ast.HexColor {
 	r := c.R + uint32(num.Value)
 	g := c.G + uint32(num.Value)
 	b := c.B + uint32(num.Value)
 	hex := ast.Hex(fmt.Sprintf("#%02X%02X%02X", r, g, b))
-	return &ast.HexColor{hex, r, g, b, nil}
+	return &ast.HexColor{
+		Hex:   hex,
+		R:     r,
+		G:     g,
+		B:     b,
+		Token: nil,
+	}
 }
 
 func uintsub(a, b uint32) uint32 {
@@ -27,23 +34,41 @@ func HexColorSubNumber(c *ast.HexColor, num *ast.Number) *ast.HexColor {
 	g := uintsub(c.G, val)
 	b := uintsub(c.B, val)
 	hex := ast.Hex(fmt.Sprintf("#%02X%02X%02X", r, g, b))
-	return &ast.HexColor{hex, r, g, b, nil}
+	return &ast.HexColor{
+		Hex:   hex,
+		R:     r,
+		G:     g,
+		B:     b,
+		Token: nil,
+	}
 }
 
 func HexColorMulNumber(color *ast.HexColor, num *ast.Number) *ast.HexColor {
 	r := uint32(math.Floor(float64(color.R) * num.Value))
 	g := uint32(math.Floor(float64(color.G) * num.Value))
 	b := uint32(math.Floor(float64(color.B) * num.Value))
 	hex := ast.Hex(fmt.Sprintf("#%02X%02X%02X", r, g, b))
-	return &ast.HexColor{hex, r, g, b, nil}
+	return &ast.HexColor{
+		Hex:   hex,
+		R:     r,
+		G:     g,
+		B:     b,
+		Token: nil,
+	}
 }
 
 func HexColorDivNumber(color *ast.HexColor, num *ast.Number) *ast.HexColor {
 	r := uint32(math.Floor(float64(color.R) / num.Value))
 	g := uint32(math.Floor(float64(color.G) / num.Value))
 	b := uint32(math.Floor(float64(color.B) / num.Value))
 	hex := ast.Hex(fmt.Sprintf("#%02X%02X%02X", r, g, b))
-	return &ast.HexColor{hex, r, g, b, nil}
+	return &ast.HexColor{
+		Hex:   hex,
+		R:     r,
+		G:     g,
+		B:     b,
+		Token: nil,
+	}
 }
 
 func RGBColorAddNumber(c *ast.RGBColor, n *ast.Number) *ast.RGBColor {

runtime/compute.go

@@ -425,13 +425,6 @@ func EvaluateExpr(expr ast.Expr, context *Context) ast.Value {
 
 	}
 
-	// shouldn't call here.
-	if IsValue(expr) {
-		return ast.Value(expr)
-	}
-
-	panic("EvaluateExpr: Unsupported expression type")
-	return nil
 }
 
 func EvaluateFunctionCall(fcall ast.FunctionCall, context *Context) ast.Value {