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]

• Read up
  Read up

Method checker.resolveFiles has a Cognitive Complexity of 278 (exceeds 20 allowed). Consider refactoring.

Open

func (check *checker) resolveFiles(files []*ast.File) {
    pkg := check.pkg

    // Phase 1: Pre-declare all package-level objects so that they can be found
    //          independent of source order. Associate methods with receiver

• Read up
  Read up

File deadcode.go has 1877 lines of code (exceeds 500 allowed). Consider refactoring.

Open

// Copyright 2013 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.

// +build ignore

File static.go has 1824 lines of code (exceeds 500 allowed). Consider refactoring.

Open

// DO NOT EDIT ** This file was generated with the bake tool ** DO NOT EDIT //

package static

var Files = map[string]string{

Method checker.stmt has a Cognitive Complexity of 214 (exceeds 20 allowed). Consider refactoring.

Open

func (check *checker) stmt(ctxt stmtContext, s ast.Stmt) {
    // statements cannot use iota in general
    // (constant declarations set it explicitly)
    assert(check.iota == nil)

• Read up
  Read up

File builder.go has 1652 lines of code (exceeds 500 allowed). Consider refactoring.

Open

// Copyright 2013 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.

package ssa

Method checker.builtin has a Cognitive Complexity of 193 (exceeds 20 allowed). Consider refactoring.

Open

func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ bool) {
    // append is the only built-in that permits the use of ... for the last argument
    bin := predeclaredFuncs[id]
    if call.Ellipsis.IsValid() && id != _Append {
        check.invalidOp(call.Ellipsis, "invalid use of ... with built-in %s", bin.name)

• Read up
  Read up

File ops.go has 1194 lines of code (exceeds 500 allowed). Consider refactoring.

Open

// Copyright 2013 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.

package interp

File reflect.go has 1178 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package pointer

// This file implements the generation and resolution rules for
// constraints arising from the use of reflection in the target
// program.  See doc.go for explanation of the representation.

Function binop has 442 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func binop(op token.Token, t types.Type, x, y value) value {
    switch op {
    case token.ADD:
        switch x.(type) {
        case int:

File index.go has 1081 lines of code (exceeds 500 allowed). Consider refactoring.

Open

// Copyright 2009 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 contains the infrastructure to create an

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.

Method checker.builtin has 417 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (check *checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ bool) {
    // append is the only built-in that permits the use of ... for the last argument
    bin := predeclaredFuncs[id]
    if call.Ellipsis.IsValid() && id != _Append {
        check.invalidOp(call.Ellipsis, "invalid use of ... with built-in %s", bin.name)

Method checker.stmt has 404 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (check *checker) stmt(ctxt stmtContext, s ast.Stmt) {
    // statements cannot use iota in general
    // (constant declarations set it explicitly)
    assert(check.iota == nil)

File cloud.rb has 797 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'json'
require 'membrane'
require 'ruby_vim_sdk'
require 'cloud'
require 'cloud/vsphere/retry_block'

Function asmCheck has a Cognitive Complexity of 102 (exceeds 20 allowed). Consider refactoring.

Open

func asmCheck(pkg *Package) {
    if !vet("asmdecl") {
        return
    }

• Read up
  Read up

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]

Function isIdenticalInternal has a Cognitive Complexity of 96 (exceeds 20 allowed). Consider refactoring.

Open

func isIdenticalInternal(x, y Type, p *ifacePair) bool {
    if x == y {
        return true
    }

• Read up
  Read up

Method serialize has a Cognitive Complexity of 73 (exceeds 5 allowed). Consider refactoring.

Open

      def serialize(value, info, default_namespace = @default_namespace)
        return unless VmomiSupport.is_child_version(@version, info.version)

        if value.nil?
          return if info.optional?

• Read up
  Read up

Class Director has 70 methods (exceeds 20 allowed). Consider refactoring.

Open

      class Director

        DIRECTOR_HTTP_ERROR_CODES = [400, 403, 404, 500]

        API_TIMEOUT     = 86400 * 3