File conv.go has 546 lines of code (exceeds 500 allowed). Consider refactoring.

Open

// Package convert provides functions for converting data and functions between Go and Starlark.
package convert

import (
    "errors"

Function updateDict has a Cognitive Complexity of 32 (exceeds 20 allowed). Consider refactoring.

Open

func updateDict(dict *GoMap, updates starlark.Tuple, kwargs []starlark.Tuple) error {
    if len(updates) == 1 {
        switch updates := updates[0].(type) {
        case starlark.NoneType:
            // no-op

• Read up
  Read up

Function toValue has 64 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func toValue(val reflect.Value, tagName string) (result starlark.Value, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic recovered: %v", r)
        }

Function updateDict has 8 return statements (exceeds 4 allowed).

Open

func updateDict(dict *GoMap, updates starlark.Tuple, kwargs []starlark.Tuple) error {
    if len(updates) == 1 {
        switch updates := updates[0].(type) {
        case starlark.NoneType:
            // no-op

Avoid deeply nested control flow statements.

Open

            if unwrapped.Type().ConvertibleTo(targetType) {
                return unwrapped.Convert(targetType), nil
            } else if sv, ok := unwrapped.Interface().(starlark.Value); ok {
                // TODO: this path is not reachable in the current test, maybe we can remove it?
                goVal := FromValue(sv)

Function convertElemValue has 7 return statements (exceeds 4 allowed).

Open

func convertElemValue(val reflect.Value, targetType reflect.Type) (reflect.Value, error) {
    if val.Type().AssignableTo(targetType) || val.Type().ConvertibleTo(targetType) {
        return val.Convert(targetType), nil
    } else if val.Kind() == reflect.Ptr || val.Kind() == reflect.Interface {
        if val.IsNil() {

Function toValue has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.

Open

func toValue(val reflect.Value, tagName string) (result starlark.Value, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic recovered: %v", r)
        }

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                } else if l != 2 {
                    return fmt.Errorf("dictionary update sequence element #%d has length %d, want 2", i, l)
                }

Function convertReflectValue has 6 return statements (exceeds 4 allowed).

Open

func convertReflectValue(val reflect.Value, argT reflect.Type) (reflect.Value, error) {
    if !val.IsValid() {
        return reflect.Zero(argT), nil
    }
    if val.Type().AssignableTo(argT) {

Function makeOut has 6 return statements (exceeds 4 allowed).

Open

func makeOut(out []reflect.Value, tagName string) (starlark.Value, error) {
    if len(out) == 0 {
        return starlark.None, nil
    }
    last := out[len(out)-1]

Function list_remove has 5 return statements (exceeds 4 allowed).

Open

func list_remove(fnname string, g *GoSlice, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    if len(args) != 1 {
        return nil, fmt.Errorf("remove: got %d arguments, want 1", len(args))
    }
    if err := g.checkMutable("remove from"); err != nil {

Function toValue has 5 return statements (exceeds 4 allowed).

Open

func toValue(val reflect.Value, tagName string) (result starlark.Value, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic recovered: %v", r)
        }

Method GoMap.SetKey has 5 return statements (exceeds 4 allowed).

Open

func (g *GoMap) SetKey(k, v starlark.Value) (err error) {
    if g.frozen {
        return fmt.Errorf("cannot insert into frozen map")
    }
    if g.numIt > 0 {

Function list_pop has 5 return statements (exceeds 4 allowed).

Open

func list_pop(fnname string, g *GoSlice, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    index := g.v.Len() - 1
    switch len(args) {
    case 0:
        // ok

Method Cache.Run has 5 return statements (exceeds 4 allowed).

Open

func (c *Cache) Run(filename string, globals map[string]interface{}) (map[string]interface{}, error) {
    dict, err := convert.MakeStringDict(globals)
    if err != nil {
        return nil, err
    }

Function dict_pop has 5 return statements (exceeds 4 allowed).

Open

func dict_pop(fnname string, g *GoMap, args starlark.Tuple, _ []starlark.Tuple) (starlark.Value, error) {
    if len(args) == 0 || len(args) > 2 {
        return nil, fmt.Errorf("%s: got %d arguments, want 1 or 2", fnname, len(args))
    }
    v, found, err := g.Delete(args[0])

Function dict_popitem has 5 return statements (exceeds 4 allowed).

Open

func dict_popitem(fnname string, g *GoMap, args starlark.Tuple, _ []starlark.Tuple) (starlark.Value, error) {
    if len(args) > 0 {
        return nil, fmt.Errorf("%s: wanted 0 args, got %d", fnname, len(args))
    }
    keys := g.v.MapKeys()

Function list_extend has 5 return statements (exceeds 4 allowed).

Open

func list_extend(fnname string, g *GoSlice, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    if len(args) != 1 {
        return nil, fmt.Errorf("extend: got %d arguments, want 1", len(args))
    }
    if err := g.checkMutable("extend"); err != nil {

Function list_insert has 5 return statements (exceeds 4 allowed).

Open

func list_insert(fnname string, g *GoSlice, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    if len(args) != 2 {
        return nil, fmt.Errorf("extend: got %d arguments, want 2", len(args))
    }
    if err := g.checkMutable("insert into"); err != nil {