optimise code style

language/ast/arguments.go

@@ -16,12 +16,8 @@ func NewArgument(arg *Argument) *Argument {
 	if arg == nil {
 		arg = &Argument{}
 	}
-	return &Argument{
-		Kind:  kinds.Argument,
-		Loc:   arg.Loc,
-		Name:  arg.Name,
-		Value: arg.Value,
-	}
+	arg.Kind = kinds.Argument
+	return arg
 }
 
 func (arg *Argument) GetKind() string {

language/ast/definitions.go

@@ -39,15 +39,8 @@ func NewOperationDefinition(op *OperationDefinition) *OperationDefinition {
 	if op == nil {
 		op = &OperationDefinition{}
 	}
-	return &OperationDefinition{
-		Kind:                kinds.OperationDefinition,
-		Loc:                 op.Loc,
-		Operation:           op.Operation,
-		Name:                op.Name,
-		VariableDefinitions: op.VariableDefinitions,
-		Directives:          op.Directives,
-		SelectionSet:        op.SelectionSet,
-	}
+	op.Kind = kinds.OperationDefinition
+	return op
 }
 
 func (op *OperationDefinition) GetKind() string {
@@ -143,13 +136,8 @@ func NewVariableDefinition(vd *VariableDefinition) *VariableDefinition {
 	if vd == nil {
 		vd = &VariableDefinition{}
 	}
-	return &VariableDefinition{
-		Kind:         kinds.VariableDefinition,
-		Loc:          vd.Loc,
-		Variable:     vd.Variable,
-		Type:         vd.Type,
-		DefaultValue: vd.DefaultValue,
-	}
+	vd.Kind = kinds.VariableDefinition
+	return vd
 }
 
 func (vd *VariableDefinition) GetKind() string {

language/ast/name.go

@@ -15,11 +15,8 @@ func NewName(node *Name) *Name {
 	if node == nil {
 		node = &Name{}
 	}
-	return &Name{
-		Kind:  kinds.Name,
-		Value: node.Value,
-		Loc:   node.Loc,
-	}
+	node.Kind = kinds.Name
+	return node
 }
 
 func (node *Name) GetKind() string {

language/ast/selections.go

@@ -28,15 +28,8 @@ func NewField(f *Field) *Field {
 	if f == nil {
 		f = &Field{}
 	}
-	return &Field{
-		Kind:         kinds.Field,
-		Loc:          f.Loc,
-		Alias:        f.Alias,
-		Name:         f.Name,
-		Arguments:    f.Arguments,
-		Directives:   f.Directives,
-		SelectionSet: f.SelectionSet,
-	}
+	f.Kind = kinds.Field
+	return f
 }
 
 func (f *Field) GetKind() string {
@@ -128,11 +121,8 @@ func NewSelectionSet(ss *SelectionSet) *SelectionSet {
 	if ss == nil {
 		ss = &SelectionSet{}
 	}
-	return &SelectionSet{
-		Kind:       kinds.SelectionSet,
-		Loc:        ss.Loc,
-		Selections: ss.Selections,
-	}
+	ss.Kind = kinds.SelectionSet
+	return ss
 }
 
 func (ss *SelectionSet) GetKind() string {

language/ast/types.go

@@ -26,11 +26,8 @@ func NewNamed(t *Named) *Named {
 	if t == nil {
 		t = &Named{}
 	}
-	return &Named{
-		Kind: kinds.Named,
-		Loc:  t.Loc,
-		Name: t.Name,
-	}
+	t.Kind = kinds.Named
+	return t
 }
 
 func (t *Named) GetKind() string {

language/ast/values.go

@@ -31,11 +31,8 @@ func NewVariable(v *Variable) *Variable {
 	if v == nil {
 		v = &Variable{}
 	}
-	return &Variable{
-		Kind: kinds.Variable,
-		Loc:  v.Loc,
-		Name: v.Name,
-	}
+	v.Kind = kinds.Variable
+	return v
 }
 
 func (v *Variable) GetKind() string {

language/parser/parser.go

@@ -249,20 +249,18 @@ func parseOperationType(parser *Parser) (string, error) {
  */
 func parseVariableDefinitions(parser *Parser) ([]*ast.VariableDefinition, error) {
 	variableDefinitions := []*ast.VariableDefinition{}
-	if peek(parser, lexer.TokenKind[lexer.PAREN_L]) {
-		vdefs, err := reverse(parser,
-			lexer.TokenKind[lexer.PAREN_L], parseVariableDefinition, lexer.TokenKind[lexer.PAREN_R],
-			true,
-		)
+	if !peek(parser, lexer.TokenKind[lexer.PAREN_L]) {
+		return nil, nil
+	}
+	if vdefs, err := reverse(parser,
+		lexer.TokenKind[lexer.PAREN_L], parseVariableDefinition, lexer.TokenKind[lexer.PAREN_R],
+		true,
+	); err != nil {
+		return variableDefinitions, nil
+	} else {
 		for _, vdef := range vdefs {
-			if vdef != nil {
-				variableDefinitions = append(variableDefinitions, vdef.(*ast.VariableDefinition))
-			}
-		}
-		if err != nil {
-			return variableDefinitions, err
+			variableDefinitions = append(variableDefinitions, vdef.(*ast.VariableDefinition))
 		}
-		return variableDefinitions, nil
 	}
 	return variableDefinitions, nil
 }
@@ -271,28 +269,28 @@ func parseVariableDefinitions(parser *Parser) ([]*ast.VariableDefinition, error)
  * VariableDefinition : Variable : Type DefaultValue?
  */
 func parseVariableDefinition(parser *Parser) (interface{}, error) {
+	var (
+		variable *ast.Variable
+		ttype    ast.Type
+		err      error
+	)
 	start := parser.Token.Start
-	variable, err := parseVariable(parser)
-	if err != nil {
+	if variable, err = parseVariable(parser); err != nil {
 		return nil, err
 	}
-	_, err = expect(parser, lexer.TokenKind[lexer.COLON])
-	if err != nil {
+	if _, err = expect(parser, lexer.TokenKind[lexer.COLON]); err != nil {
 		return nil, err
 	}
-	ttype, err := parseType(parser)
-	if err != nil {
+	if ttype, err = parseType(parser); err != nil {
 		return nil, err
 	}
 	var defaultValue ast.Value
 	if skp, err := skip(parser, lexer.TokenKind[lexer.EQUALS]); err != nil {
 		return nil, err
 	} else if skp {
-		dv, err := parseValueLiteral(parser, true)
-		if err != nil {
+		if defaultValue, err = parseValueLiteral(parser, true); err != nil {
 			return nil, err
 		}
-		defaultValue = dv
 	}
 	return ast.NewVariableDefinition(&ast.VariableDefinition{
 		Variable:     variable,
@@ -306,13 +304,15 @@ func parseVariableDefinition(parser *Parser) (interface{}, error) {
  * Variable : $ Name
  */
 func parseVariable(parser *Parser) (*ast.Variable, error) {
+	var (
+		err  error
+		name *ast.Name
+	)
 	start := parser.Token.Start
-	_, err := expect(parser, lexer.TokenKind[lexer.DOLLAR])
-	if err != nil {
+	if _, err = expect(parser, lexer.TokenKind[lexer.DOLLAR]); err != nil {
 		return nil, err
 	}
-	name, err := parseName(parser)
-	if err != nil {
+	if name, err = parseName(parser); err != nil {
 		return nil, err
 	}
 	return ast.NewVariable(&ast.Variable{
@@ -326,17 +326,16 @@ func parseVariable(parser *Parser) (*ast.Variable, error) {
  */
 func parseSelectionSet(parser *Parser) (*ast.SelectionSet, error) {
 	start := parser.Token.Start
-	iSelections, err := reverse(parser,
+	selections := []ast.Selection{}
+	if iSelections, err := reverse(parser,
 		lexer.TokenKind[lexer.BRACE_L], parseSelection, lexer.TokenKind[lexer.BRACE_R],
 		true,
-	)
-	if err != nil {
+	); err != nil {
 		return nil, err
-	}
-	selections := []ast.Selection{}
-	for _, iSelection := range iSelections {
-		// type assert interface{} into Selection interface
-		selections = append(selections, iSelection.(ast.Selection))
+	} else {
+		for _, iSelection := range iSelections {
+			selections = append(selections, iSelection.(ast.Selection))
+		}
 	}
 
 	return ast.NewSelectionSet(&ast.SelectionSet{
@@ -353,8 +352,7 @@ func parseSelectionSet(parser *Parser) (*ast.SelectionSet, error) {
  */
 func parseSelection(parser *Parser) (interface{}, error) {
 	if peek(parser, lexer.TokenKind[lexer.SPREAD]) {
-		r, err := parseFragment(parser)
-		return r, err
+		return parseFragment(parser)
 	}
 	return parseField(parser)
 }
@@ -412,15 +410,15 @@ func parseField(parser *Parser) (*ast.Field, error) {
 func parseArguments(parser *Parser) ([]*ast.Argument, error) {
 	arguments := []*ast.Argument{}
 	if peek(parser, lexer.TokenKind[lexer.PAREN_L]) {
-		iArguments, err := reverse(parser,
+		if iArguments, err := reverse(parser,
 			lexer.TokenKind[lexer.PAREN_L], parseArgument, lexer.TokenKind[lexer.PAREN_R],
 			true,
-		)
-		if err != nil {
+		); err != nil {
 			return arguments, err
-		}
-		for _, iArgument := range iArguments {
-			arguments = append(arguments, iArgument.(*ast.Argument))
+		} else {
+			for _, iArgument := range iArguments {
+				arguments = append(arguments, iArgument.(*ast.Argument))
+			}
 		}
 	}
 	return arguments, nil
@@ -462,9 +460,11 @@ func parseArgument(parser *Parser) (interface{}, error) {
  * InlineFragment : ... TypeCondition? Directives? SelectionSet
  */
 func parseFragment(parser *Parser) (interface{}, error) {
+	var (
+		err error
+	)
 	start := parser.Token.Start
-	_, err := expect(parser, lexer.TokenKind[lexer.SPREAD])
-	if err != nil {
+	if _, err = expect(parser, lexer.TokenKind[lexer.SPREAD]); err != nil {
 		return nil, err
 	}
 	if peek(parser, lexer.TokenKind[lexer.NAME]) && parser.Token.Value != "on" {
@@ -518,7 +518,7 @@ func parseFragment(parser *Parser) (interface{}, error) {
  */
 func parseFragmentDefinition(parser *Parser) (ast.Node, error) {
 	start := parser.Token.Start
-	_, err := expectKeyWord(parser, "fragment")
+	_, err := expectKeyWord(parser, lexer.FRAGMENT)
 	if err != nil {
 		return nil, err
 	}
@@ -738,15 +738,12 @@ func parseObjectField(parser *Parser, isConst bool) (*ast.ObjectField, error) {
  */
 func parseDirectives(parser *Parser) ([]*ast.Directive, error) {
 	directives := []*ast.Directive{}
-	for {
-		if !peek(parser, lexer.TokenKind[lexer.AT]) {
-			break
-		}
-		directive, err := parseDirective(parser)
-		if err != nil {
+	for peek(parser, lexer.TokenKind[lexer.AT]) {
+		if directive, err := parseDirective(parser); err != nil {
 			return directives, err
+		} else {
+			directives = append(directives, directive)
 		}
-		directives = append(directives, directive)
 	}
 	return directives, nil
 }
@@ -944,7 +941,7 @@ func parseScalarTypeDefinition(parser *Parser) (ast.Node, error) {
 	if err != nil {
 		return nil, err
 	}
-	_, err = expectKeyWord(parser, "scalar")
+	_, err = expectKeyWord(parser, lexer.SCALAR)
 	if err != nil {
 		return nil, err
 	}
@@ -976,7 +973,7 @@ func parseObjectTypeDefinition(parser *Parser) (ast.Node, error) {
 	if err != nil {
 		return nil, err
 	}
-	_, err = expectKeyWord(parser, "type")
+	_, err = expectKeyWord(parser, lexer.TYPE)
 	if err != nil {
 		return nil, err
 	}
@@ -1161,7 +1158,7 @@ func parseInterfaceTypeDefinition(parser *Parser) (ast.Node, error) {
 	if err != nil {
 		return nil, err
 	}
-	_, err = expectKeyWord(parser, "interface")
+	_, err = expectKeyWord(parser, lexer.INTERFACE)
 	if err != nil {
 		return nil, err
 	}
@@ -1204,7 +1201,7 @@ func parseUnionTypeDefinition(parser *Parser) (ast.Node, error) {
 	if err != nil {
 		return nil, err
 	}
-	_, err = expectKeyWord(parser, "union")
+	_, err = expectKeyWord(parser, lexer.UNION)
 	if err != nil {
 		return nil, err
 	}
@@ -1264,7 +1261,7 @@ func parseEnumTypeDefinition(parser *Parser) (ast.Node, error) {
 	if err != nil {
 		return nil, err
 	}
-	_, err = expectKeyWord(parser, "enum")
+	_, err = expectKeyWord(parser, lexer.ENUM)
 	if err != nil {
 		return nil, err
 	}
@@ -1335,7 +1332,7 @@ func parseInputObjectTypeDefinition(parser *Parser) (ast.Node, error) {
 	if err != nil {
 		return nil, err
 	}
-	_, err = expectKeyWord(parser, "input")
+	_, err = expectKeyWord(parser, lexer.INPUT)
 	if err != nil {
 		return nil, err
 	}
@@ -1374,7 +1371,7 @@ func parseInputObjectTypeDefinition(parser *Parser) (ast.Node, error) {
  */
 func parseTypeExtensionDefinition(parser *Parser) (ast.Node, error) {
 	start := parser.Token.Start
-	_, err := expectKeyWord(parser, "extend")
+	_, err := expectKeyWord(parser, lexer.EXTEND)
 	if err != nil {
 		return nil, err
 	}
@@ -1405,7 +1402,7 @@ func parseDirectiveDefinition(parser *Parser) (ast.Node, error) {
 	if description, err = parseDescription(parser); err != nil {
 		return nil, err
 	}
-	if _, err = expectKeyWord(parser, "directive"); err != nil {
+	if _, err = expectKeyWord(parser, lexer.DIRECTIVE); err != nil {
 		return nil, err
 	}
 	if _, err = expect(parser, lexer.TokenKind[lexer.AT]); err != nil {

language/printer/printer.go

@@ -4,9 +4,10 @@ import (
 	"fmt"
 	"strings"
 
+	"reflect"
+
 	"github.com/graphql-go/graphql/language/ast"
 	"github.com/graphql-go/graphql/language/visitor"
-	"reflect"
 )
 
 func getMapValue(m map[string]interface{}, key string) interface{} {