Method checker.resolveFiles has 270 lines of code (exceeds 50 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

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
    }

• Read up
  Read up

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

Open

func (check *checker) selector(x *operand, e *ast.SelectorExpr) {
    // these must be declared before the "goto Error" statements
    var (
        obj      Object
        index    []int

• Read up
  Read up

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

Open

module Bosh::CloudStackCloud
  ##
  # BOSH CloudStack CPI
  class Cloud < Bosh::Cloud
    include Helpers

File release.rb has 563 lines of code (exceeds 250 allowed). Consider refactoring.

Open

module Bosh::Cli::Command
  class Release < Base
    DEFAULT_RELEASE_NAME = 'bosh-release'

    include Bosh::Cli::DependencyHelper

File director.rb has 561 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'cli/core_ext'
require 'cli/errors'

require 'json'
require 'httpclient'

Method checker.blockBranches has a Cognitive Complexity of 75 (exceeds 20 allowed). Consider refactoring.

Open

func (check *checker) blockBranches(all *Scope, parent *block, lstmt *ast.LabeledStmt, list []ast.Stmt) []*ast.BranchStmt {
    b := &block{parent: parent, lstmt: lstmt}

    var (
        varDeclPos         token.Pos

• Read up
  Read up

Function parseSections has a Cognitive Complexity of 75 (exceeds 20 allowed). Consider refactoring.

Open

func parseSections(ctx *Context, name string, lines *Lines, number []int, doc *Doc) ([]Section, error) {
    var sections []Section
    for i := 1; ; i++ {
        // Next non-empty line is title.
        text, ok := lines.nextNonEmpty()

• Read up
  Read up

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

Open

module Bosh::OpenStackCloud
  ##
  # BOSH OpenStack CPI
  class Cloud < Bosh::Cloud
    include Helpers

Function lookupFieldOrMethod has a Cognitive Complexity of 74 (exceeds 20 allowed). Consider refactoring.

Open

func lookupFieldOrMethod(T Type, pkg *Package, name string) (obj Object, index []int, indirect bool) {
    // WARNING: The code in this function is extremely subtle - do not modify casually!
    //          This function and NewMethodSet should be kept in sync.

    if name == "_" {

• Read up
  Read up

File gen.go has 799 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 pointer

Function conv has a Cognitive Complexity of 73 (exceeds 20 allowed). Consider refactoring.

Open

func conv(t_dst, t_src types.Type, x value) value {
    ut_src := t_src.Underlying()
    ut_dst := t_dst.Underlying()

    // Destination type is not an "untyped" type.

• Read up
  Read up

Method sanity.checkBlock has a Cognitive Complexity of 73 (exceeds 20 allowed). Consider refactoring.

Open

func (s *sanity) checkBlock(b *BasicBlock, index int) {
    s.block = b

    if b.Index != index {
        s.errorf("block has incorrect Index %d", b.Index)

• Read up
  Read up

Method builder.stmt has a Cognitive Complexity of 73 (exceeds 20 allowed). Consider refactoring.

Open

func (b *builder) stmt(fn *Function, _s ast.Stmt) {
    // The label of the current statement.  If non-nil, its _goto
    // target is always set; its _break and _continue are set only
    // within the body of switch/typeswitch/select/for/range.
    // It is effectively an additional default-nil parameter of stmt().

• Read up
  Read up

Method validate_options has a Cognitive Complexity of 55 (exceeds 5 allowed). Consider refactoring.

Open

      def validate_options(options)
        raise "Invalid options format, Hash expected, #{options.class} given" unless options.is_a?(Hash)
        raise 'Swift container name is missing' unless options.has_key?(:container_name)
        raise 'Swift provider is missing' unless options.has_key?(:swift_provider)
        case options[:swift_provider]

• Read up
  Read up

Function NewMethodSet has a Cognitive Complexity of 69 (exceeds 20 allowed). Consider refactoring.

Open

func NewMethodSet(T Type) *MethodSet {
    // WARNING: The code in this function is extremely subtle - do not modify casually!
    //          This function and lookupFieldOrMethod should be kept in sync.

    // method set up to the current depth, allocated lazily

• Read up
  Read up

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

• Read up
  Read up

Function init has 229 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func init() {
    // Key strings are from Function.String().
    // That little dot ۰ is an Arabic zero numeral (U+06F0),
    // categories [Nd].
    intrinsicsByName = map[string]intrinsic{

Method show_deployment has a Cognitive Complexity of 49 (exceeds 5 allowed). Consider refactoring.

Open

    def show_deployment(name, options={})
      say("Deployment `#{name.make_green}'")

      vms = director.fetch_vm_state(name)

• Read up
  Read up

Method File.asmParseDecl has 206 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (f *File) asmParseDecl(decl *ast.FuncDecl) map[string]*asmFunc {
    var (
        arch   *asmArch
        fn     *asmFunc
        offset int