Showing 2,859 of 2,859 total issues

Function sc_vectorCopyBang has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
Open

function sc_vectorCopyBang(target, tstart, source, sstart, send) {
    if (!sstart) sstart = 0;
    if (!send) send = source.length;

    // if target == source we don't want to overwrite not yet copied elements.
Severity: Minor
Found in deps/v8/benchmarks/earley-boyer.js - About 45 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 (hexC >= '0' && hexC <= '9') {
                port.readChar();
                nb = nb * 16 + hexC.charCodeAt(0) - '0'.charCodeAt(0);
            } else if (hexC >= 'a' && hexC <= 'f') {
                port.readChar();
Severity: Major
Found in deps/v8/benchmarks/earley-boyer.js - About 45 mins to fix

    Function processCodeCreation has 6 arguments (exceeds 4 allowed). Consider refactoring.
    Open

        type, kind, start, size, name, maybe_func) {
    Severity: Minor
    Found in deps/v8/tools/tickprocessor.js - About 45 mins to fix

      Function RunSingleBenchmark has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
      Open

      BenchmarkSuite.prototype.RunSingleBenchmark = function(benchmark, data) {
        function Measure(data) {
          var elapsed = 0;
          var start = new Date();
          for (var n = 0; elapsed < 1000; n++) {
      Severity: Minor
      Found in deps/v8/benchmarks/base.js - About 45 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 (!current.right) {
                break;
              }
      Severity: Major
      Found in deps/v8/tools/splaytree.js - About 45 mins to fix

        Avoid deeply nested control flow statements.
        Open

                                                                if ((k>=(0)))
                                                                    if (((k>=i)&&(((sc_state_99 = (sc_states_96[k])), (conf_set = (sc_state_99[(prev+(1))])), ((conf_set!== false)?(conf_set[(i+(5))]):false))!== false)))
                                                                        {
                                                                            (prev_trees = (deriv_trees(prev, i, k, sc_enders_92, sc_steps_93, sc_names_94, sc_toks_95, sc_states_96, BgL_sc_nbzd2nts_97zd2)));
                                                                            (ender_trees = (deriv_trees(ender, k, j, sc_enders_92, sc_steps_93, sc_names_94, sc_toks_95, sc_states_96, BgL_sc_nbzd2nts_97zd2)));
        Severity: Major
        Found in deps/v8/benchmarks/earley-boyer.js - About 45 mins to fix

          Function dispatchLogRow_ has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

          LogReader.prototype.dispatchLogRow_ = function(fields) {
            // Obtain the dispatch.
            var command = fields[0];
            if (!(command in this.dispatchTable_)) return;
          
          
          Severity: Minor
          Found in deps/v8/tools/logreader.js - About 45 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

                  } else if (rawSourceFilter.exec(line) != null) {
                    readingSource = true;
                    sourceBegin = -1;
                  } else {
                    var matches = firstPositionFinder.exec(line);
          Severity: Major
          Found in deps/v8/tools/sodium/sodium.js - About 45 mins to fix

            Function makeParseable has 6 arguments (exceeds 4 allowed). Consider refactoring.
            Open

            function makeParseable (data, long, dir, depth, parent, d) {
            Severity: Minor
            Found in deps/npm/lib/ls.js - About 45 mins to fix

              Function lifecycle has 6 arguments (exceeds 4 allowed). Consider refactoring.
              Open

              function lifecycle (pkg, stage, wd, unsafe, failOk, cb) {
              Severity: Minor
              Found in deps/npm/lib/utils/lifecycle.js - About 45 mins to fix

                Function run has 6 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                  this.run = function(filename,
                                      resx, resy,
                                      distortion,
                                      range_start, range_end) {
                Severity: Minor
                Found in deps/v8/tools/profviz/profviz.js - About 45 mins to fix

                  Function normalize has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                  Open

                  function normalize (args) {
                    var normalized = ""
                    if (args.length > 0) {
                      var a = npa(args[0])
                      if (a.name) normalized = a.name
                  Severity: Minor
                  Found in deps/npm/lib/cache.js - About 45 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 (matches != null) {
                                asmBegin = begin;
                              }
                  Severity: Major
                  Found in deps/v8/tools/sodium/sodium.js - About 45 mins to fix

                    Avoid deeply nested control flow statements.
                    Open

                                if (matches != null) {
                                  startAddress = matches[1];
                                }
                    Severity: Major
                    Found in deps/v8/tools/sodium/sodium.js - About 45 mins to fix

                      Function dedupe_ has 6 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                      function dedupe_ (dir, filter, unavoidable, dryrun, silent, cb) {
                      Severity: Minor
                      Found in deps/npm/lib/dedupe.js - About 45 mins to fix

                        Function makeParseable_ has 6 arguments (exceeds 4 allowed). Consider refactoring.
                        Open

                        function makeParseable_ (data, long, dir, depth, parent, d) {
                        Severity: Minor
                        Found in deps/npm/lib/ls.js - About 45 mins to fix

                          Function lifecycle has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                          Open

                          function lifecycle (pkg, stage, wd, unsafe, failOk, cb) {
                            if (typeof cb !== "function") cb = failOk, failOk = false
                            if (typeof cb !== "function") cb = unsafe, unsafe = false
                            if (typeof cb !== "function") cb = wd, wd = null
                          
                          
                          Severity: Minor
                          Found in deps/npm/lib/utils/lifecycle.js - About 45 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

                          Function makeArchy_ has 6 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                          function makeArchy_ (data, long, dir, depth, parent, d) {
                          Severity: Minor
                          Found in deps/npm/lib/ls.js - About 45 mins to fix

                            Function findEntry has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                            Open

                                findEntry: function(lineNumber, columnNumber)
                                {
                                    var first = 0;
                                    var count = this._mappings.length;
                                    while (count > 1) {
                            Severity: Minor
                            Found in deps/v8/tools/SourceMap.js - About 45 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

                            Function makePretty has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                            Open

                            function makePretty (p) {
                              var dep = p[1]
                                , dir = path.resolve(p[0], "node_modules", dep)
                                , has = p[2]
                                , want = p[3]
                            Severity: Minor
                            Found in deps/npm/lib/outdated.js - About 45 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

                            Severity
                            Category
                            Status
                            Source
                            Language