Sign upLogin

cloudfoundry-community/bosh-cloudstack-cpi

View on GitHub
Star
go_agent/src/code.google.com/p/go.tools/go/types/expr.go

Summary

Maintainability
F
2 wks
Test Coverage

Method checker.exprInternal has a Cognitive Complexity of 322 (exceeds 20 allowed). Consider refactoring.
Open

func (check *checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
    // make sure x has a valid state in case of bailout
    // (was issue 5770)
    x.mode = invalid
    x.typ = Typ[Invalid]
Severity: Minor
Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 6 days to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

File expr.go has 1072 lines of code (exceeds 500 allowed). Consider refactoring.
Open

// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file implements typechecking of expressions.
Severity: Major
Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 1 day to fix

    Method checker.exprInternal has 370 lines of code (exceeds 50 allowed). Consider refactoring.
    Open

    func (check *checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
    // make sure x has a valid state in case of bailout
    // (was issue 5770)
    x.mode = invalid
    x.typ = Typ[Invalid]
    Severity: Major
    Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 1 day to fix

      Method checker.convertUntyped has a Cognitive Complexity of 77 (exceeds 20 allowed). Consider refactoring.
      Open

      func (check *checker) convertUntyped(x *operand, target Type) {
    if x.mode == invalid || isTyped(x.typ) {
        return
    }
      Severity: Minor
      Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 1 day to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function isRepresentableConst has a Cognitive Complexity of 68 (exceeds 20 allowed). Consider refactoring.
      Open

      func isRepresentableConst(x exact.Value, conf *Config, as BasicKind, rounded *exact.Value) bool {
    switch x.Kind() {
    case exact.Unknown:
        return true
      Severity: Minor
      Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 1 day to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function isRepresentableConst has 125 lines of code (exceeds 50 allowed). Consider refactoring.
      Open

      func isRepresentableConst(x exact.Value, conf *Config, as BasicKind, rounded *exact.Value) bool {
    switch x.Kind() {
    case exact.Unknown:
        return true
      Severity: Major
      Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 4 hrs to fix

        Function isRepresentableConst has 23 return statements (exceeds 4 allowed).
        Open

        func isRepresentableConst(x exact.Value, conf *Config, as BasicKind, rounded *exact.Value) bool {
    switch x.Kind() {
    case exact.Unknown:
        return true
        Severity: Major
        Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 2 hrs to fix

          Method checker.convertUntyped has 68 lines of code (exceeds 50 allowed). Consider refactoring.
          Open

          func (check *checker) convertUntyped(x *operand, target Type) {
    if x.mode == invalid || isTyped(x.typ) {
        return
    }
          Severity: Minor
          Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 1 hr to fix

            Method checker.updateExprType has 58 lines of code (exceeds 50 allowed). Consider refactoring.
            Open

            func (check *checker) updateExprType(x ast.Expr, typ Type, final bool) {
    old, found := check.untyped[x]
    if !found {
        return // nothing to do
    }
            Severity: Minor
            Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 1 hr to fix

              Method checker.binary has 56 lines of code (exceeds 50 allowed). Consider refactoring.
              Open

              func (check *checker) binary(x *operand, lhs, rhs ast.Expr, op token.Token) {
    var y operand

    check.expr(x, lhs)
    check.expr(&y, rhs)
              Severity: Minor
              Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 1 hr to fix

                Method checker.shift has 52 lines of code (exceeds 50 allowed). Consider refactoring.
                Open

                func (check *checker) shift(x, y *operand, op token.Token) {
    untypedx := isUntyped(x.typ)

    // The lhs must be of integer type or be representable
    // as an integer; otherwise the shift has no chance.
                Severity: Minor
                Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 1 hr to fix

                  Method checker.binary has 10 return statements (exceeds 4 allowed).
                  Open

                  func (check *checker) binary(x *operand, lhs, rhs ast.Expr, op token.Token) {
    var y operand

    check.expr(x, lhs)
    check.expr(&y, rhs)
                  Severity: Major
                  Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 1 hr to fix

                    Method checker.indexedElts has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.
                    Open

                    func (check *checker) indexedElts(elts []ast.Expr, typ Type, length int64) int64 {
    visited := make(map[int64]bool, len(elts))
    var index, max int64
    for _, e := range elts {
        // determine and check index
                    Severity: Minor
                    Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 55 mins to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Avoid deeply nested control flow statements.
                    Open

                                            if x.mode != invalid {
                            check.errorf(x.pos(), "cannot use %s as %s value in struct literal", x, etyp)
                        }
                    Severity: Major
                    Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 45 mins to fix

                      Avoid deeply nested control flow statements.
                      Open

                                          goto Error
                      Severity: Major
                      Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                            goto Error
                        Severity: Major
                        Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 45 mins to fix

                          Avoid deeply nested control flow statements.
                          Open

                                                  if x.mode != invalid {
                            check.errorf(x.pos(), "cannot use %s as %s value in struct literal", x, etyp)
                        }
                          Severity: Major
                          Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 45 mins to fix

                            Avoid deeply nested control flow statements.
                            Open

                                                goto Error
                            Severity: Major
                            Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 45 mins to fix

                              Avoid deeply nested control flow statements.
                              Open

                                                  goto Error
                              Severity: Major
                              Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 45 mins to fix

                                Method checker.index has 7 return statements (exceeds 4 allowed).
                                Open

                                func (check *checker) index(index ast.Expr, max int64) (i int64, valid bool) {
    var x operand
    check.expr(&x, index)
    if x.mode == invalid {
        return
                                Severity: Major
                                Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 45 mins to fix

                                  Method checker.unary has 7 return statements (exceeds 4 allowed).
                                  Open

                                  func (check *checker) unary(x *operand, op token.Token) {
    switch op {
    case token.AND:
        // spec: "As an exception to the addressability
        // requirement x may also be a composite literal."
                                  Severity: Major
                                  Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 45 mins to fix

                                    Method checker.shift has 7 return statements (exceeds 4 allowed).
                                    Open

                                    func (check *checker) shift(x, y *operand, op token.Token) {
    untypedx := isUntyped(x.typ)

    // The lhs must be of integer type or be representable
    // as an integer; otherwise the shift has no chance.
                                    Severity: Major
                                    Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 45 mins to fix

                                      Consider simplifying this complex logical expression.
                                      Open

                                          if (op == token.QUO || op == token.REM) && (x.mode == constant || isInteger(x.typ)) && y.mode == constant && exact.Sign(y.val) == 0 {
                                      Severity: Major
                                      Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 40 mins to fix

                                        Method checker.binary has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.
                                        Open

                                        func (check *checker) binary(x *operand, lhs, rhs ast.Expr, op token.Token) {
    var y operand

    check.expr(x, lhs)
    check.expr(&y, rhs)
                                        Severity: Minor
                                        Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 35 mins to fix

                                        Cognitive Complexity

                                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                        A method's cognitive complexity is based on a few simple rules:

                                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                        • Code is considered more complex for each "break in the linear flow of the code"
                                        • Code is considered more complex when "flow breaking structures are nested"

                                        Further reading

                                        Method checker.shift has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.
                                        Open

                                        func (check *checker) shift(x, y *operand, op token.Token) {
    untypedx := isUntyped(x.typ)

    // The lhs must be of integer type or be representable
    // as an integer; otherwise the shift has no chance.
                                        Severity: Minor
                                        Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 35 mins to fix

                                        Cognitive Complexity

                                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                        A method's cognitive complexity is based on a few simple rules:

                                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                        • Code is considered more complex for each "break in the linear flow of the code"
                                        • Code is considered more complex when "flow breaking structures are nested"

                                        Further reading

                                        Method checker.exprInternal has 5 return statements (exceeds 4 allowed).
                                        Open

                                        func (check *checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
    // make sure x has a valid state in case of bailout
    // (was issue 5770)
    x.mode = invalid
    x.typ = Typ[Invalid]
                                        Severity: Major
                                        Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go - About 35 mins to fix

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  case Complex64:
            if rounded == nil {
                return fitsFloat32(exact.Real(x)) && fitsFloat32(exact.Imag(x))
            }
            re := roundFloat32(exact.Real(x))
                                          Severity: Minor
                                          Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go and 1 other location - About 1 hr to fix
                                          go_agent/src/code.google.com/p/go.tools/go/types/expr.go on lines 306..315

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 129.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                          Open

                                                  case Complex128:
            if rounded == nil {
                return fitsFloat64(exact.Real(x)) && fitsFloat64(exact.Imag(x))
            }
            re := roundFloat64(exact.Real(x))
                                          Severity: Minor
                                          Found in go_agent/src/code.google.com/p/go.tools/go/types/expr.go and 1 other location - About 1 hr to fix
                                          go_agent/src/code.google.com/p/go.tools/go/types/expr.go on lines 296..305

                                          Duplicated Code

                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                          Tuning

                                          This issue has a mass of 129.

                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                          Refactorings

                                          Further Reading

                                          There are no issues that match your filters.

                                          Category
                                          Status