func convExpr()

in convertast/convert_ast.go [166:283]
118 lines of code
24 McCabe index (conditional complexity)

func convExpr(e syntax.Expr) build.Expr {
	if e == nil {
		return nil
	}
	switch e := e.(type) {
	case *syntax.Literal:
		switch e.Token {
		case syntax.INT:
			return &build.LiteralExpr{
				Token:    strconv.FormatInt(e.Value.(int64), 10),
				Comments: convComments(e.Comments())}
		case syntax.FLOAT:
			return &build.LiteralExpr{
				Token:    e.Raw,
				Comments: convComments(e.Comments())}
		case syntax.STRING:
			return &build.StringExpr{
				Value:       e.Value.(string),
				TripleQuote: strings.HasPrefix(e.Raw, "\"\"\""),
				Comments:    convComments(e.Comments())}
		}
	case *syntax.Ident:
		return &build.Ident{Name: e.Name, Comments: convComments(e.Comments())}
	case *syntax.BinaryExpr:
		_, lhsEnd := e.X.Span()
		rhsBegin, _ := e.Y.Span()
		if e.Op.String() == "=" {
			return &build.AssignExpr{
				LHS:       convExpr(e.X),
				RHS:       convExpr(e.Y),
				Op:        e.Op.String(),
				LineBreak: lhsEnd.Line != rhsBegin.Line,
				Comments:  convComments(e.Comments())}
		}
		return &build.BinaryExpr{
			X:         convExpr(e.X),
			Y:         convExpr(e.Y),
			Op:        e.Op.String(),
			LineBreak: lhsEnd.Line != rhsBegin.Line,
			Comments:  convComments(e.Comments())}
	case *syntax.UnaryExpr:
		return &build.UnaryExpr{Op: e.Op.String(), X: convExpr(e.X)}
	case *syntax.SliceExpr:
		return &build.SliceExpr{X: convExpr(e.X), From: convExpr(e.Lo), To: convExpr(e.Hi), Step: convExpr(e.Step)}
	case *syntax.DotExpr:
		return &build.DotExpr{X: convExpr(e.X), Name: e.Name.Name}
	case *syntax.CallExpr:
		args := []build.Expr{}
		for _, a := range e.Args {
			args = append(args, convExpr(a))
		}
		return &build.CallExpr{
			X:            convExpr(e.Fn),
			List:         args,
			ForceCompact: singleLine(e),
		}
	case *syntax.ListExpr:
		list := []build.Expr{}
		for _, i := range e.List {
			list = append(list, convExpr(i))
		}
		return &build.ListExpr{List: list, Comments: convComments(e.Comments())}
	case *syntax.DictExpr:
		list := []*build.KeyValueExpr{}
		for i := range e.List {
			entry := e.List[i].(*syntax.DictEntry)
			list = append(list, &build.KeyValueExpr{
				Key:      convExpr(entry.Key),
				Value:    convExpr(entry.Value),
				Comments: convComments(entry.Comments()),
			})
		}
		return &build.DictExpr{List: list, Comments: convComments(e.Comments())}
	case *syntax.CondExpr:
		return &build.ConditionalExpr{
			Then:     convExpr(e.True),
			Test:     convExpr(e.Cond),
			Else:     convExpr(e.False),
			Comments: convComments(e.Comments()),
		}
	case *syntax.Comprehension:
		return &build.Comprehension{
			Body:     convExpr(e.Body),
			Clauses:  convClauses(e.Clauses),
			Comments: convComments(e.Comments()),
			Curly:    e.Curly,
		}
	case *syntax.ParenExpr:
		return &build.ParenExpr{
			X:        convExpr(e.X),
			Comments: convComments(e.Comments()),
		}
	case *syntax.TupleExpr:
		return &build.TupleExpr{
			List:         convExprs(e.List),
			NoBrackets:   !e.Lparen.IsValid(),
			Comments:     convComments(e.Comments()),
			ForceCompact: singleLine(e),
		}
	case *syntax.IndexExpr:
		return &build.IndexExpr{
			X:        convExpr(e.X),
			Y:        convExpr(e.Y),
			Comments: convComments(e.Comments()),
		}
	case *syntax.LambdaExpr:
		return &build.LambdaExpr{
			Comments: convComments(e.Comments()),
			Function: build.Function{
				Params: convExprs(e.Params),
				Body:   []build.Expr{convExpr(e.Body)},
			},
		}
	default:
		panic(fmt.Sprintf("other expr: %T %+v", e, e))
	}
	panic("unreachable")
}