Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Regression build failure in no-dupe-keys #6886

Closed
ilyavolodin opened this issue Aug 11, 2016 · 1 comment
Closed

Regression build failure in no-dupe-keys #6886

ilyavolodin opened this issue Aug 11, 2016 · 1 comment
Labels
accepted There is consensus among the team that this change meets the criteria for inclusion archived due to age This issue has been archived; please open a new issue for any further discussion bug ESLint is working incorrectly rule Relates to ESLint's core rules

Comments

@ilyavolodin
Copy link
Member

Regression build failed overnight with the changes made to no-dupe-key rule yesterday. It failed while running tests of eslint-plugin-import, below is the log:

eslint-plugin-import

  • node node_modules/eslint/bin/eslint -v
    v3.2.2
  • npm run test

eslint-plugin-import@1.12.0 test /var/lib/jenkins/workspace/Regression Build/eslint-plugin-import
cross-env BABEL_ENV=test NODE_PATH=./src nyc mocha --recursive tests/src -t 5s

CLI regression tests
issue #210

  ��� doesn't throw an error on gratuitous, erroneous self-reference (126ms)

getExports

��� should handle ExportAllDeclaration (48ms)

��� should return a cached copy on subsequent requests

��� should not return a cached copy after modification

��� should not return a cached copy with different settings

��� should not throw for a missing file

��� should export explicit names for a missing file in exports

��� finds exports for an ES7 module with babel-eslint
deprecation metadata
  default parser
    deprecated imports

      ��� works with named imports.

      ��� works with default imports.

      ��� works with variables.
      multi-line variables

        ��� works for the first one

        ��� works for the second one

        ��� works for the third one, etc.
    full module

      ��� has JSDoc metadata
  babel-eslint
    deprecated imports

      ��� works with named imports.

      ��� works with default imports.

      ��� works with variables.
      multi-line variables

        ��� works for the first one

        ��� works for the second one

        ��� works for the third one, etc.
    full module

      ��� has JSDoc metadata
exported static namespaces

  ��� works with espree & traditional namespace exports

  ��� captures namespace exported as default

  ��� works with babel-eslint & ES7 namespace exports
deep namespace caching

  ��� works
Map API
  #size

    ��� counts the names

    ��� includes exported namespace size
issue #210: self-reference

  ��� doesn't crash

  ��� 'has' circular reference

  ��� can 'get' circular reference

importType(name)

��� should return 'builtin' for node.js modules

��� should return 'external' for non-builtin modules without a relative path (64ms)

��� should return 'external' for scopes packages

��� should return 'internal' for non-builtins resolved outside of node_modules

��� should return 'parent' for internal modules that go through the parent

��� should return 'sibling' for internal modules that are connected to one of the siblings

��� should return 'unknown' for any unhandled cases

��� should return 'builtin' for additional core modules

��� should return 'external' for module from 'node_modules' with default config

��� should return 'internal' for module from 'node_modules' if 'node_modules' missed in 'external-module-folders'

��� should return 'external' for module from 'node_modules' if 'node_modules' contained in 'external-module-folders'

parse(content, { settings, ecmaFeatures })

��� doesn't support JSX by default

��� infers jsx from ecmaFeatures when using stock parser

resolve

��� should throw on bad parameters.

��� loads a custom resolver path (52ms)

��� respects import/resolve extensions

��� should test case sensitivity
case cache correctness
  ./CaseyKasem.js => ./CASEYKASEM.js
    finite cache

      ��� gets correct values after cache lifetime

package

��� exists

��� has every rule

��� exports all configs

��� has configs only for rules that exist

default
valid

  ��� import "./malformed.js"

  ��� import foo from "./empty-folder";

  ��� import { foo } from "./default-export";

  ��� import foo from "./default-export";

  ��� import foo from "./mixed-exports";

  ��� import bar from "./default-export";

  ��� import CoolClass from "./default-class";

  ��� import bar, { baz } from "./default-export";

  ��� import crypto from "crypto";

  ��� import common from "./common";

  ��� export bar from "./bar"

  ��� export { default as bar } from "./bar"

  ��� export bar, { foo } from "./bar"

  ��� export { default as bar, foo } from "./bar"

  ��� export bar, * as names from "./bar"

  ��� export {a} from "./named-exports"

  ��� import twofer from "./trampoline"

  ��� import MyCoolComponent from "./jsx/MyCoolComponent.jsx"

  ��� import foo from "./named-default-export"

  ��� import connectedApp from "./redux"

  ��� import App from "./jsx/App"

  ��� import Foo from './jsx/FooES7.js';

  ��� for (let { foo, bar } of baz) {}

  ��� for (let [ foo, bar ] of baz) {}

  ��� const { x, y } = bar

  ��� const { x, y, ...z } = bar

  ��� export { x }

  ��� export { x as y }

  ��� export const x = null

  ��� export var x = null

  ��� export let x = null

  ��� export default x

  ��� export default class x {}

  ��� import json from "./data.json"

  ��� import foo from "./foobar.json";

  ��� import foo from "./foobar";

  ��� import { foo } from "./issue-370-commonjs-namespace/bar"

  ��� export * from "./issue-370-commonjs-namespace/bar" (42ms)
invalid

  ��� import Foo from './jsx/FooES7.js'; (58ms)

  ��� import crypto from "./common";

  ��� import baz from "./named-exports";

  ��� import bar from "./common";

  ��� import Foo from './jsx/FooES7.js';

  ��� export baz from "./named-exports" (49ms)

  ��� export baz, { bar } from "./named-exports"

  ��� export baz, * as names from "./named-exports"

  ��� import twofer from "./broken-trampoline"

  ��� import barDefault from "./re-export"

export
valid

  ��� import "./malformed.js"

  ��� var foo = "foo"; export default foo;

  ��� export var foo = "foo"; export var bar = "bar";

  ��� export var foo = "foo", bar = "bar";

  ��� export var { foo, bar } = object;

  ��� export var [ foo, bar ] = array;

  ��� export var { foo, bar } = object;

  ��� export var [ foo, bar ] = array;

  ��� export { foo, foo as bar }

  ��� export { bar }; export * from "./export-all"

  ��� export * from "./export-all"

  ��� export * from "./does-not-exist"

  ��� export default foo; export * from "./bar"

  ��� for (let { foo, bar } of baz) {}

  ��� for (let [ foo, bar ] of baz) {}

  ��� const { x, y } = bar

  ��� const { x, y, ...z } = bar

  ��� export { x }

  ��� export { x as y }

  ��� export const x = null

  ��� export var x = null

  ��� export let x = null

  ��� export default x

  ��� export default class x {}

  ��� import json from "./data.json"

  ��� import foo from "./foobar.json";

  ��� import foo from "./foobar";

  ��� import { foo } from "./issue-370-commonjs-namespace/bar"

  ��� export * from "./issue-370-commonjs-namespace/bar"
invalid

  ��� export default foo; export default bar

  ��� export default function foo() {}; export default function bar() {}

  ��� export function foo() {}; export { bar as foo }

  ��� export {foo}; export {foo};

  ��� export {foo}; export {bar as foo};

  ��� export var foo = "foo"; export var foo = "bar";

  ��� export var foo = "foo", foo = "bar";

  ��� export { foo }; export * from "./export-all"

  ��� export * from "./malformed.js"

  ��� export var { foo, bar } = object; export var foo = "bar" (54ms)

  ��� export var { bar: { foo } } = object; export var foo = "bar"

  ��� export var [ foo, bar ] = array; export var bar = "baz"

  ��� export var [ foo, /*sparse*/, { bar } ] = array; export var bar = "baz"

  ��� export * from "./default-export"

extensions
valid

  ��� import a from "a"

  ��� import dot from "./file.with.dot"

  ��� import a from "a/index.js"

  ��� import dot from "./file.with.dot.js"

  ��� import a from "a"

import packageConfig from "./package.json"

  ��� import lib from "./bar"

import component from "./bar.jsx"
import data from "./bar.json"

  ��� import path from "path"

  ��� import path from "path"

  ��� import path from "path"

  ��� import thing from "./fake-file.js"

  ��� import thing from "non-package"
invalid

  ��� import a from "a/index.js"

  ��� import a from "a"

  ��� import dot from "./file.with.dot"

  ��� import a from "a/index.js"

import packageConfig from "./package"

  ��� import lib from "./bar.js"

import component from "./bar.jsx"
import data from "./bar.json"

  ��� import lib from "./bar.js"

import component from "./bar.jsx"
import data from "./bar.json"

  ��� import thing from "./fake-file.js"

  ��� import thing from "non-package"

imports-first
valid

  ��� import { x } from './foo'; import { y } from './bar';                  export { x, y }

  ��� import { x } from 'foo'; import { y } from './bar'

  ��� import { x } from './foo'; import { y } from 'bar'

  ��� 'use directive';                  import { x } from 'foo';
invalid

  ��� import { x } from './foo';                  export { x };                  import { y } from './foo';

  ��� import { x } from './foo';                  export { x };                  import { y } from './bar';                  import { z } from './baz';

  ��� import { x } from './foo'; import { y } from 'bar'

  ��� import { x } from 'foo';                  'use directive';                  import { y } from 'bar';

named
valid

  ��� import "./malformed.js"

  ��� import { foo } from "./bar"

  ��� import { foo } from "./empty-module"

  ��� import bar from "./bar.js"

  ��� import bar, { foo } from "./bar.js"

  ��� import {a, b, d} from "./named-exports"

  ��� import {ExportedClass} from "./named-exports"

  ��� import { ActionTypes } from "./qc"

  ��� import {a, b, c, d} from "./re-export"

  ��� import { jsxFoo } from "./jsx/AnotherComponent"

  ��� import {a, b, d} from "./common"; // eslint-disable-line named

  ��� import { foo, bar } from "./re-export-names"

  ��� import { foo, bar } from "./common"

  ��� import { foo } from "crypto"

  ��� import { zoob } from "a"

  ��� import { someThing } from "./test-module"

  ��� import { zoob } from "a"

  ��� export { foo } from "./bar"

  ��� export { foo as bar } from "./bar"

  ��� export { foo } from "./does-not-exist"

  ��� export bar, { foo } from "./bar"

  ��� import { foo, bar } from "./named-trampoline"

  ��� export { foo as bar }

  ��� import { destructuredProp } from "./named-exports"

  ��� import { arrayKeyProp } from "./named-exports"

  ��� import { deepProp } from "./named-exports"

  ��� import { deepSparseElement } from "./named-exports"

  ��� import type { MyType } from "./flowtypes"

  ��� /*jsnext*/ import { createStore } from "redux"

  ��� /*jsnext*/ import { createStore } from "redux"

  ��� import { foo } from "es6-module"

  ��� import { me, soGreat } from "./narcissist"

  ��� import { foo, bar, baz } from "./re-export-default"

  ��� import { common } from "./re-export-default"

  ��� for (let { foo, bar } of baz) {}

  ��� for (let [ foo, bar ] of baz) {}

  ��� const { x, y } = bar

  ��� const { x, y, ...z } = bar

  ��� export { x }

  ��� export { x as y }

  ��� export const x = null

  ��� export var x = null

  ��� export let x = null

  ��� export default x

  ��� export default class x {}

  ��� import json from "./data.json"

  ��� import foo from "./foobar.json";

  ��� import foo from "./foobar";

  ��� import { foo } from "./issue-370-commonjs-namespace/bar"

  ��� export * from "./issue-370-commonjs-namespace/bar"
invalid

  ��� import { zoob } from "a"

  ��� import { somethingElse } from "./test-module"

  ��� import {a, b, d} from "./common"

  ��� import { baz } from "./bar"

  ��� import { baz, bop } from "./bar"

  ��� import {a, b, c} from "./named-exports"

  ��� import { a } from "./default-export"

  ��� import { a } from "./common"

  ��� import { ActionTypess } from "./qc"

  ��� import {a, b, c, d, e} from "./re-export"

  ��� import { a } from "./re-export-names"

  ��� export { bar } from "./bar"

  ��� export bar2, { bar } from "./bar"

  ��� import { foo, bar, baz } from "./named-trampoline"

  ��� import { baz } from "./broken-trampoline"

  ��� import { a } from './test.coffee';

  ��� import type { MissingType } from "./flowtypes"

  ��� /*jsnext*/ import { createSnorlax } from "redux"

  ��� /*jsnext*/ import { createSnorlax } from "redux"

  ��� import { baz } from "es6-module"

  ��� import { baz } from "./bar"

  ��� import { foo, bar, bap } from "./re-export-default"

  ��� import { common } from "./re-export-default"

  ��� import { default as barDefault } from "./re-export"

namespace
valid

  ��� import "./malformed.js"

  ��� import * as foo from './empty-folder';

  ��� import * as names from "./named-exports"; console.log((names.b).c); 

  ��� import * as names from "./named-exports"; console.log(names.a);

  ��� import * as names from "./re-export-names"; console.log(names.foo);

  ��� import * as elements from './jsx';

  ��� import * as foo from './common';

  ��� import * as names from "./named-exports";const { a } = names

  ��� import * as names from "./named-exports";const { d: c } = names

  ��� import * as names from "./named-exports";const { c } = foo
, { length } = "names"
, alt = names

  ��� import * as names from "./named-exports";const { ExportedClass: { length } } = names

  ��� import * as names from "./named-exports";function b(names) { const { c } = names }

  ��� import * as names from "./named-exports";function b() { let names = null; const { c } = names }

  ��� import * as names from "./named-exports";const x = function names() { const { c } = names }

  ��� export * as names from "./named-exports"

  ��� export defport, * as names from "./named-exports"

  ��� export * as names from "./does-not-exist"

  ��� import * as Endpoints from "./issue-195/Endpoints"; console.log(Endpoints.Users)

  ��� function x() { console.log((names.b).c); } import * as names from "./named-exports"; 

  ��� import * as names from './default-export';

  ��� import * as names from './default-export'; console.log(names.default)

  ��� export * as names from "./default-export"

  ��� export defport, * as names from "./default-export"

  ��� import * as names from './named-exports'; console.log(names['a']);

  ��� for (let { foo, bar } of baz) {}

  ��� for (let [ foo, bar ] of baz) {}

  ��� const { x, y } = bar

  ��� const { x, y, ...z } = bar

  ��� export { x }

  ��� export { x as y }

  ��� export const x = null

  ��� export var x = null

  ��� export let x = null

  ��� export default x

  ��� export default class x {}

  ��� import json from "./data.json"

  ��� import foo from "./foobar.json";

  ��� import foo from "./foobar";

  ��� import { foo } from "./issue-370-commonjs-namespace/bar"

  ��� export * from "./issue-370-commonjs-namespace/bar"

  ��� import * as a from "./deep/a"; console.log(a.b.c.d.e)

  ��� import { b } from "./deep/a"; console.log(b.c.d.e)

  ��� import * as a from "./deep/a"; console.log(a.b.c.d.e.f)

  ��� import * as a from "./deep/a"; var {b:{c:{d:{e}}}} = a

  ��� import { b } from "./deep/a"; var {c:{d:{e}}} = b

  ��� import * as a from "./deep-es7/a"; console.log(a.b.c.d.e)

  ��� import { b } from "./deep-es7/a"; console.log(b.c.d.e) (40ms)

  ��� import * as a from "./deep-es7/a"; console.log(a.b.c.d.e.f) (49ms)

  ��� import * as a from "./deep-es7/a"; var {b:{c:{d:{e}}}} = a (41ms)

  ��� import { b } from "./deep-es7/a"; var {c:{d:{e}}} = b (49ms)
invalid

  ��� import * as foo from './common';

  ��� import * as names from './named-exports';  console.log(names.c);

  ��� import * as names from './named-exports'; console.log(names['a']);

  ��� import * as foo from './bar'; foo.foo = 'y';

  ��� import * as foo from './bar'; foo.x = 'y';

  ��� import * as names from "./named-exports"; const { c } = names

  ��� import * as names from "./named-exports"; function b() { const { c } = names }

  ��� import * as names from "./named-exports"; const { c: d } = names

  ��� import * as names from "./named-exports";const { c: { d } } = names

  ��� import * as Endpoints from "./issue-195/Endpoints"; console.log(Endpoints.Foo)

  ��� import * as namespace from './malformed.js';

  ��� import b from './deep/default'; console.log(b.e)

  ��� console.log(names.c);import * as names from './named-exports'; 

  ��� function x() { console.log(names.c) } import * as names from './named-exports'; 

  ��� import * as ree from "./re-export"; console.log(ree.default)

  ��� import * as a from "./deep/a"; console.log(a.b.e)

  ��� import { b } from "./deep/a"; console.log(b.e)

  ��� import * as a from "./deep/a"; console.log(a.b.c.e)

  ��� import { b } from "./deep/a"; console.log(b.c.e)

  ��� import * as a from "./deep/a"; var {b:{ e }} = a

  ��� import * as a from "./deep/a"; var {b:{c:{ e }}} = a

  ��� import * as a from "./deep-es7/a"; console.log(a.b.e) (43ms)

  ��� import { b } from "./deep-es7/a"; console.log(b.e)

  ��� import * as a from "./deep-es7/a"; console.log(a.b.c.e)

  ��� import { b } from "./deep-es7/a"; console.log(b.c.e)

  ��� import * as a from "./deep-es7/a"; var {b:{ e }} = a

  ��� import * as a from "./deep-es7/a"; var {b:{c:{ e }}} = a

newline-after-import
valid

  ��� var path = require('path');

var foo = require('foo');

  ��� require('foo');

  ��� switch ('foo') { case 'bar': require('baz'); }

  ��� 
    const x = () => require('baz')
        , y = () => require('bar')

  ��� const x = () => require('baz') && require('bar')

  ��� function x(){ require('baz'); }

  ��� a(require('b'), require('c'), require('d'));

  ��� function foo() {
  switch (renderData.modalViewKey) {
    case 'value':
      var bar = require('bar');
      return bar(renderData, options)
    default:
      return renderData.mainModalContent.clone()
  }
}

  ��� //issue 441
function bar() {
  switch (foo) {
    case '1':
      return require('../path/to/file1.jst.hbs')(renderData, options);
    case '2':
      return require('../path/to/file2.jst.hbs')(renderData, options);
    case '3':
      return require('../path/to/file3.jst.hbs')(renderData, options);
    case '4':
      return require('../path/to/file4.jst.hbs')(renderData, options);
    case '5':
      return require('../path/to/file5.jst.hbs')(renderData, options);
    case '6':
      return require('../path/to/file6.jst.hbs')(renderData, options);
    case '7':
      return require('../path/to/file7.jst.hbs')(renderData, options);
    case '8':
      return require('../path/to/file8.jst.hbs')(renderData, options);
    case '9':
      return require('../path/to/file9.jst.hbs')(renderData, options);
    case '10':
      return require('../path/to/file10.jst.hbs')(renderData, options);
    case '11':
      return require('../path/to/file11.jst.hbs')(renderData, options);
    case '12':
      return something();
    default:
      return somethingElse();
  }
} (92ms)

  ��� import path from 'path';

import foo from 'foo';

  ��� import path from 'path';import foo from 'foo';


  ��� import path from 'path';import foo from 'foo';

var bar = 42;

  ��� import foo from 'foo';

var foo = 'bar';

  ��� var foo = require('foo-module');

var foo = 'bar';

  ��� require('foo-module');

var foo = 'bar';

  ��� import foo from 'foo';

import { bar } from './bar-lib';

  ��� import foo from 'foo';

var a = 123;

import { bar } from './bar-lib';

  ��� var foo = require('foo-module');

var a = 123;

var bar = require('bar-lib');
invalid

  ��� import foo from 'foo';

export default function() {};

  ��� var foo = require('foo-module');

var something = 123;

  ��� import foo from 'foo';

var a = 123;

import { bar } from './bar-lib';
var b=456;

  ��� var foo = require('foo-module');

var a = 123;

var bar = require('bar-lib');
var b=456;

  ��� var foo = require('foo-module');

var a = 123;

require('bar-lib');
var b=456;

  ��� var path = require('path');

var foo = require('foo');
var bar = 42;

  ��� var assign = Object.assign || require('object-assign');

var foo = require('foo');
var bar = 42;

  ��� function a() {

var assign = Object.assign || require('object-assign');
var foo = require('foo');
var bar = 42; }

  ��� require('a');

foo(require('b'), require('c'), require('d'));
require('d');
var foo = 'bar';

  ��� require('a');

foo(
require('b'),
require('c'),
require('d')
);
var foo = 'bar';

  ��� import path from 'path';

import foo from 'foo';
var bar = 42;

  ��� import path from 'path';import foo from 'foo';var bar = 42;

no-amd
valid

  ��� import "x";

  ��� import x from "x"

  ��� var x = require("x")

  ��� require("x")

  ��� require("x", "y")

  ��� setTimeout(foo, 100)

  ��� (a || b)(1, 2, 3)

  ��� function x() { define(["a"], function (a) {}) }

  ��� function x() { require(["a"], function (a) {}) }

  ��� define(0, 1, 2)

  ��� define("a")
invalid

  ��� define([], function() {})

  ��� define(["a"], function(a) { console.log(a); })

  ��� require([], function() {})

  ��� require(["a"], function(a) { console.log(a); })

no-commonjs
valid

  ��� import "x";

  ��� import x from "x"

  ��� import x from "x"

  ��� import { x } from "x"

  ��� export default "x"

  ��� export function house() {}

  ��� function a() { var x = require("y"); }

  ��� require.resolve("help")

  ��� require.ensure([])

  ��� require([], function(a, b, c) {})

  ��� var bar = require('./bar', true);

  ��� var bar = proxyquire('./bar');

  ��� var bar = require('./ba' + 'r');

  ��� var zero = require(0);

  ��� module.exports = function () {}

  ��� module.exports = "foo"
invalid

  ��� var x = require("x")

  ��� require("x")

  ��� exports.face = "palm"

  ��� module.exports.face = "palm"

  ��� module.exports = face

  ��� exports = module.exports = {}

  ��� var x = module.exports = {}

  ��� module.exports = {}

  ��� var x = module.exports

no-deprecated
valid

  ��� import { x } from './fake' 

  ��� import bar from './bar'

  ��� import { fine } from './deprecated'

  ��� import { _undocumented } from './deprecated'

  ��� import { fn } from './deprecated'

  ��� import { fine } from './tomdoc-deprecated'

  ��� import { _undocumented } from './tomdoc-deprecated'

  ��� import * as depd from './deprecated'

  ��� import * as depd from './deprecated'; console.log(depd.fine())

  ��� import { deepDep } from './deep-deprecated'

  ��� import { deepDep } from './deep-deprecated'; console.log(deepDep.fine())

  ��� import { deepDep } from './deep-deprecated'; function x(deepDep) { console.log(deepDep.MY_TERRIBLE_ACTION) }

  ��� for (let { foo, bar } of baz) {}

  ��� for (let [ foo, bar ] of baz) {}

  ��� const { x, y } = bar

  ��� const { x, y, ...z } = bar

  ��� export { x }

  ��� export { x as y }

  ��� export const x = null

  ��� export var x = null

  ��� export let x = null (57ms)

  ��� export default x

  ��� export default class x {}

  ��� import json from "./data.json"

  ��� import foo from "./foobar.json";

  ��� import foo from "./foobar";

  ��� import { foo } from "./issue-370-commonjs-namespace/bar"

  ��� export * from "./issue-370-commonjs-namespace/bar"
invalid

  ��� import './malformed.js'

  ��� import { fn } from './deprecated'

  ��� import TerribleClass from './deprecated'

  ��� import { MY_TERRIBLE_ACTION } from './deprecated'

  ��� import { fn } from './deprecated'

  ��� import { fn } from './tomdoc-deprecated'

  ��� import TerribleClass from './tomdoc-deprecated'

  ��� import { MY_TERRIBLE_ACTION } from './tomdoc-deprecated'

  ��� import { MY_TERRIBLE_ACTION } from './deprecated'; function shadow(MY_TERRIBLE_ACTION) { console.log(MY_TERRIBLE_ACTION); }

  ��� import { MY_TERRIBLE_ACTION, fine } from './deprecated'; console.log(fine)

  ��� import { MY_TERRIBLE_ACTION } from './deprecated'; console.log(MY_TERRIBLE_ACTION)

  ��� import { MY_TERRIBLE_ACTION } from './deprecated'; console.log(someOther.MY_TERRIBLE_ACTION)

  ��� import { MY_TERRIBLE_ACTION } from './deprecated'; console.log(MY_TERRIBLE_ACTION.whatever())

  ��� import { MY_TERRIBLE_ACTION } from './deprecated'; console.log(MY_TERRIBLE_ACTION(this, is, the, worst))

  ��� import Thing from './deprecated-file'

  ��� import Thing from './deprecated-file'; console.log(other.Thing)

  ��� import * as depd from './deprecated'; console.log(depd.MY_TERRIBLE_ACTION)

  ��� import * as deep from './deep-deprecated'; console.log(deep.deepDep.MY_TERRIBLE_ACTION)

  ��� import { deepDep } from './deep-deprecated'; console.log(deepDep.MY_TERRIBLE_ACTION)

  ��� import { deepDep } from './deep-deprecated'; function x(deepNDep) { console.log(deepDep.MY_TERRIBLE_ACTION) }

no-deprecated: hoisting
valid

  ��� function x(deepDep) { console.log(deepDep.MY_TERRIBLE_ACTION) } import { deepDep } from './deep-deprecated'
invalid

  ��� console.log(MY_TERRIBLE_ACTION); import { MY_TERRIBLE_ACTION } from './deprecated'

no-duplicates
valid

  ��� import "./malformed.js"

  ��� import { x } from './foo'; import { y } from './bar'

  ��� import foo from "234artaf";import { shoop } from "234q25ad"

  ��� import { x } from './foo'; import type { y } from './foo'
invalid

  ��� import { x } from './foo'; import { y } from './foo'

  ��� import { x } from './foo'; import { y } from './foo'; import { z } from './foo'

  ��� import { x } from './bar'; import { y } from 'bar';

  ��� import foo from 'non-existent'; import bar from 'non-existent'; (41ms)

  ��� import type { x } from './foo'; import type { y } from './foo'

no-extraneous-dependencies
valid

  ��� import "lodash.cond"

  ��� import "pkg-up"

  ��� import foo, { bar } from "lodash.cond"

  ��� import foo, { bar } from "pkg-up"

  ��� import "eslint"

  ��� import "eslint/lib/api"

  ��� require("lodash.cond")

  ��� require("pkg-up")

  ��� var foo = require("lodash.cond")

  ��� var foo = require("pkg-up")

  ��� import "fs"

  ��� import "./foo"

  ��� import "lodash.isarray"

  ��� import "@scope/core"

  ��� import "electron"

  ��� import "eslint"

  ��� import "eslint"

  ��� import "importType"
invalid

  ��� import "not-a-dependency"

  ��� var donthaveit = require("@scope/donthaveit")

  ��� var donthaveit = require("@scope/donthaveit/lib/foo")

  ��� import "eslint"

  ��� import "lodash.isarray"

  ��� var foo = require("not-a-dependency")

  ��� var glob = require("glob")

  ��� var eslint = require("lodash.isarray")

no-mutable-exports
valid

  ��� export const count = 1

  ��� export function getCount() {}

  ��� export class Counter {}

  ��� export default count = 1

  ��� export default function getCount() {}

  ��� export default class Counter {}

  ��� const count = 1

export { count }

  ��� const count = 1

export { count as counter }

  ��� const count = 1

export default count

  ��� const count = 1

export { count as default }

  ��� function getCount() {}

export { getCount }

  ��� function getCount() {}

export { getCount as getCounter } (79ms)

  ��� function getCount() {}

export default getCount

  ��� function getCount() {}

export { getCount as default }

  ��� class Counter {}

export { Counter }

  ��� class Counter {}

export { Counter as Count }

  ��� class Counter {}

export default Counter

  ��� class Counter {}

export { Counter as default }

  ��� export Something from "./something";
invalid

  ��� export let count = 1

  ��� export var count = 1

  ��� let count = 1

export { count }

  ��� var count = 1

export { count }

  ��� let count = 1

export { count as counter }

  ��� var count = 1

export { count as counter }

  ��� let count = 1

export default count

  ��� var count = 1

export default count

no-named-as-default-member
valid

  ��� import bar, {foo} from "./bar";

  ��� import bar from "./bar"; const baz = bar.baz

  ��� import {foo} from "./bar"; const baz = foo.baz;

  ��� import * as named from "./named-exports"; const a = named.a

  ��� for (let { foo, bar } of baz) {}

  ��� for (let [ foo, bar ] of baz) {}

  ��� const { x, y } = bar

  ��� const { x, y, ...z } = bar

  ��� export { x }

  ��� export { x as y }

  ��� export const x = null

  ��� export var x = null

  ��� export let x = null

  ��� export default x

  ��� export default class x {}

  ��� import json from "./data.json"

  ��� import foo from "./foobar.json";

  ��� import foo from "./foobar";

  ��� import { foo } from "./issue-370-commonjs-namespace/bar"

  ��� export * from "./issue-370-commonjs-namespace/bar"
invalid

  ��� import bar from "./bar"; const foo = bar.foo;

  ��� import bar from "./bar"; bar.foo();

  ��� import bar from "./bar"; const {foo} = bar;

  ��� import bar from "./bar"; const {foo: foo2, baz} = bar;

no-named-as-default
valid

  ��� import "./malformed.js"

  ��� import bar, { foo } from "./bar";

  ��� import bar, { foo } from "./empty-folder";

  ��� export bar, { foo } from "./bar";

  ��� export bar from "./bar";

  ��� for (let { foo, bar } of baz) {}

  ��� for (let [ foo, bar ] of baz) {}

  ��� const { x, y } = bar

  ��� const { x, y, ...z } = bar

  ��� export { x }

  ��� export { x as y }

  ��� export const x = null

  ��� export var x = null

  ��� export let x = null

  ��� export default x

  ��� export default class x {}

  ��� import json from "./data.json"

  ��� import foo from "./foobar.json";

  ��� import foo from "./foobar";

  ��� import { foo } from "./issue-370-commonjs-namespace/bar"

  ��� export * from "./issue-370-commonjs-namespace/bar"
invalid

  ��� import foo from "./bar";

  ��� import foo, { foo as bar } from "./bar";

  ��� export foo from "./bar";

  ��� export foo, { foo as bar } from "./bar";

  ��� import foo from "./malformed.js"

no-namespace
valid

  ��� import { a, b } from 'foo';

  ��� import { a, b } from './foo';

  ��� import bar from 'bar';

  ��� import bar from './bar';
invalid

  ��� import * as foo from 'foo';

  ��� import defaultExport, * as foo from 'foo';

  ��� import * as foo from './foo';

no-nodejs-modules
valid

  ��� import _ from "lodash"

  ��� import find from "lodash.find"

  ��� import foo from "./foo"

  ��� import foo from "../foo"

  ��� import foo from "foo"

  ��� import foo from "./"

  ��� import foo from "@scope/foo"

  ��� var _ = require("lodash")

  ��� var find = require("lodash.find")

  ��� var foo = require("./foo")

  ��� var foo = require("../foo")

  ��� var foo = require("foo")

  ��� var foo = require("./")

  ��� var foo = require("@scope/foo")
invalid

  ��� import path from "path"

  ��� import fs from "fs"

  ��� var path = require("path")

  ��� var fs = require("fs")

no-restricted-paths
valid

  ��� import a from "../client/a.js"

  ��� const a = require("../client/a.js")

  ��� import b from "../server/b.js"
invalid

  ��� import b from "../server/b.js"

  ��� import a from "../client/a"

import c from "./c"

  ��� import b from "../server/b.js"

  ��� const b = require("../server/b.js")

no-unresolved (node)
valid

  ��� import "./malformed.js"

  ��� import foo from "./bar";

  ��� import bar from './bar.js';

  ��� import {someThing} from './test-module';

  ��� import fs from 'fs';

  ��� import * as foo from "a"

  ��� export { foo } from "./bar"

  ��� export * from "./bar"

  ��� export { foo }

  ��� export * as bar from "./bar"

  ��� export bar from "./bar"

  ��� import foo from "./jsx/MyUnCoolComponent.jsx"

  ��� var foo = require("./bar")

  ��� require("./bar")

  ��� require("./does-not-exist")

  ��� require("./does-not-exist")

  ��� require(["./bar"], function (bar) {})

  ��� define(["./bar"], function (bar) {})

  ��� require(["./does-not-exist"], function (bar) {})

  ��� define(["require", "exports", "module"], function (r, e, m) { })

  ��� require(["./does-not-exist"])

  ��� define(["./does-not-exist"], function (bar) {})

  ��� require("./does-not-exist", "another arg")

  ��� proxyquire("./does-not-exist")

  ��� (function() {})("./does-not-exist")

  ��� define([0, foo], function (bar) {})

  ��� require(0)

  ��� require(foo)
invalid

  ��� import reallyfake from "./reallyfake/module"

  ��� import bar from './baz';

  ��� import bar from './baz';

  ��� import bar from './empty-folder';

  ��� import { DEEP } from 'in-alternate-root';

  ��� export { foo } from "./does-not-exist"

  ��� export * from "./does-not-exist"

  ��� export * as bar from "./does-not-exist"

  ��� export bar from "./does-not-exist"

  ��� import foo from "./jsx/MyUncoolComponent.jsx"

  ��� var bar = require("./baz")

  ��� require("./baz")

  ��� require(["./baz"], function (bar) {})

  ��� define(["./baz"], function (bar) {})

  ��� define(["./baz", "./bar", "./does-not-exist"], function (bar) {})

issue #333 (node)
valid

  ��� import foo from "./bar.json"

  ��� import foo from "./bar"

  ��� import foo from "./bar.json"

  ��� import foo from "./bar"
invalid

  ��� import bar from "./foo.json"

no-unresolved (webpack)
valid

  ��� import "./malformed.js"

  ��� import foo from "./bar"; (153ms)

  ��� import bar from './bar.js';

  ��� import {someThing} from './test-module';

  ��� import fs from 'fs';

  ��� import * as foo from "a"

  ��� export { foo } from "./bar"

  ��� export * from "./bar"

  ��� export { foo }

  ��� export * as bar from "./bar"

  ��� export bar from "./bar"

  ��� import foo from "./jsx/MyUnCoolComponent.jsx"

  ��� var foo = require("./bar")

  ��� require("./bar")

  ��� require("./does-not-exist")

  ��� require("./does-not-exist")

  ��� require(["./bar"], function (bar) {})

  ��� define(["./bar"], function (bar) {})

  ��� require(["./does-not-exist"], function (bar) {})

  ��� define(["require", "exports", "module"], function (r, e, m) { })

  ��� require(["./does-not-exist"])

  ��� define(["./does-not-exist"], function (bar) {})

  ��� require("./does-not-exist", "another arg")

  ��� proxyquire("./does-not-exist")

  ��� (function() {})("./does-not-exist")

  ��� define([0, foo], function (bar) {})

  ��� require(0)

  ��� require(foo)
invalid

  ��� import reallyfake from "./reallyfake/module"

  ��� import bar from './baz';

  ��� import bar from './baz';

  ��� import bar from './empty-folder';

  ��� import { DEEP } from 'in-alternate-root';

  ��� export { foo } from "./does-not-exist"

  ��� export * from "./does-not-exist"

  ��� export * as bar from "./does-not-exist"

  ��� export bar from "./does-not-exist"

  ��� import foo from "./jsx/MyUncoolComponent.jsx"

  ��� var bar = require("./baz")

  ��� require("./baz")

  ��� require(["./baz"], function (bar) {})

  ��� define(["./baz"], function (bar) {})

  ��� define(["./baz", "./bar", "./does-not-exist"], function (bar) {})

issue #333 (webpack)
valid

  ��� import foo from "./bar.json"

  ��� import foo from "./bar"

  ��� import foo from "./bar.json"

  ��� import foo from "./bar"
invalid

  ��� import bar from "./foo.json"

no-unresolved (import/resolve legacy)
valid

  ��� import { DEEP } from 'in-alternate-root';

  ��� import { DEEP } from 'in-alternate-root'; import { bar } from 'src-bar';

  ��� import * as foo from "jsx-module/foo"
invalid

  ��� import * as foo from "jsx-module/foo"

no-unresolved (webpack-specific)
valid

  ��� import * as foo from "jsx-module/foo"

  ��� import * as foo from "some-loader?with=args!jsx-module/foo"
invalid

  ��� import * as foo from "jsx-module/foo" (50ms)

no-unresolved ignore list
valid

  ��� import "./malformed.js"

  ��� import "./test.giffy"

  ��� import "./test.gif"

  ��� import "./test.png"
invalid

  ��� import "./test.gif"

  ��� import "./test.png"

no-unresolved unknown resolver
invalid

  ��� import "./malformed.js"

  ��� import "./malformed.js"; import "./fake.js"

no-unresolved electron
valid

  ��� import "electron"
invalid

  ��� import "electron"

no-unresolved syntax verification
valid

  ��� for (let { foo, bar } of baz) {}

  ��� for (let [ foo, bar ] of baz) {}

  ��� const { x, y } = bar

  ��� const { x, y, ...z } = bar

  ��� export { x }

  ��� export { x as y }

  ��� export const x = null

  ��� export var x = null

  ��� export let x = null

  ��� export default x

  ��� export default class x {}

  ��� import json from "./data.json"

  ��� import foo from "./foobar.json";

  ��� import foo from "./foobar";

  ��� import { foo } from "./issue-370-commonjs-namespace/bar"

  ��� export * from "./issue-370-commonjs-namespace/bar"

order
valid

  ��� 
    var fs = require('fs');
    var async = require('async');
    var relParent1 = require('../foo');
    var relParent2 = require('../foo/bar');
    var relParent3 = require('../');
    var sibling = require('./foo');
    var index = require('./');

  ��� 
    import fs from 'fs';
    import async, {foo1} from 'async';
    import relParent1 from '../foo';
    import relParent2, {foo2} from '../foo/bar';
    import relParent3 from '../';
    import sibling, {foo3} from './foo';
    import index from './';

  ��� 
    var fs = require('fs');
    var fs = require('fs');
    var path = require('path');
    var _ = require('lodash');
    var async = require('async');

  ��� 
    var index = require('./');
    var sibling = require('./foo');
    var relParent3 = require('../');
    var relParent2 = require('../foo/bar');
    var relParent1 = require('../foo');
    var async = require('async');
    var fs = require('fs');


  ��� 
    var path = require('path');
    var _ = require('lodash');
    var async = require('async');
    var fs = require('f' + 's');

  ��� 
    var path = require('path');
    var result = add(1, 2);
    var _ = require('lodash');

  ��� 
    var index = require('./');
    function foo() {
      var fs = require('fs');
    }
    () => require('fs');
    if (a) {
      require('fs');
    }

  ��� 
    var unknown1 = require('/unknown1');
    var fs = require('fs');
    var unknown2 = require('/unknown2');
    var async = require('async');
    var unknown3 = require('/unknown3');
    var foo = require('../foo');
    var unknown4 = require('/unknown4');
    var bar = require('../foo/bar');
    var unknown5 = require('/unknown5');
    var parent = require('../');
    var unknown6 = require('/unknown6');
    var foo = require('./foo');
    var unknown7 = require('/unknown7');
    var index = require('./');
    var unknown8 = require('/unknown8');


  ��� 
    require('./foo');
    require('fs');
    var path = require('path');


  ��� 
    import './foo';
    import 'fs';
    import path from 'path';


  ��� 
    function add(a, b) {
      return a + b;
    }
    var foo;


  ��� 
    var fs = require('fs');
    var index = require('./');
    var path = require('path');

    var sibling = require('./foo');
    var relParent3 = require('../');
    var async = require('async');
    var relParent1 = require('../foo');


  ��� 
    var index = require('./');
    var path = require('path');


  ��� 
    import async, {foo1} from 'async';
    import relParent2, {foo2} from '../foo/bar';
    import sibling, {foo3} from './foo';
    var fs = require('fs');
    var relParent1 = require('../foo');
    var relParent3 = require('../');
    var index = require('./');


  ��� 
    var fs = require('fs');
    var index = require('./');
    var path = require('path');



    var sibling = require('./foo');


    var relParent1 = require('../foo');
    var relParent3 = require('../');
    var async = require('async');


  ��� 
    var fs = require('fs');
    var index = require('./');
    var path = require('path');
    var sibling = require('./foo');
    var relParent1 = require('../foo');
    var relParent3 = require('../');
    var async = require('async');


  ��� 
    import path from 'path';

    import {
        I,
        Want,
        Couple,
        Imports,
        Here
    } from 'bar';
    import external from 'external'


  ��� 
    import path from 'path';
    import net
      from 'net';

    import external from 'external'


  ��� 
    import foo
      from '../../../../this/will/be/very/long/path/and/therefore/this/import/has/to/be/in/two/lines';

    import bar
      from './sibling';


  ��� 
    import path from 'path';

    import 'loud-rejection';
    import 'something-else';

    import _ from 'lodash';


  ��� 
    import path from 'path';
    import 'loud-rejection';
    import 'something-else';
    import _ from 'lodash';


  ��� 
    var path = require('path');

    require('loud-rejection');
    require('something-else');

    var _ = require('lodash');


  ��� 
    var path = require('path');
    require('loud-rejection');
    require('something-else');
    var _ = require('lodash');


  ��� 
    var some = require('asdas');
    var config = {
      port: 4444,
      runner: {
        server_path: require('runner-binary').path,

        cli_args: {
            'webdriver.chrome.driver': require('browser-binary').path
        }
      }
    }


  ��� 
    var some = require('asdas');
    var config = {
      port: 4444,
      runner: {
        server_path: require('runner-binary').path,
        cli_args: {
            'webdriver.chrome.driver': require('browser-binary').path
        }
      }
    }

invalid

  ��� 
    var async = require('async');
    var fs = require('fs');


  ��� 
    import async from 'async';
    import fs from 'fs';


  ��� 
    var async = require('async');
    import fs from 'fs';


  ��� 
    var parent = require('../parent');
    var async = require('async');


  ��� 
    var sibling = require('./sibling');
    var parent = require('../parent');


  ��� 
    var index = require('./');
    var sibling = require('./sibling');


  ��� 
    var sibling = require('./sibling');
    var async = require('async');
    var fs = require('fs');


  ��� 
    var index = require('./');
    var fs = require('fs');
    var path = require('path');
    var _ = require('lodash');
    var foo = require('foo');
    var bar = require('bar');


  ��� 
    var fs = require('fs');
    var index = require('./');


  ��� 
    var foo = require('./foo').bar;
    var fs = require('fs');


  ��� 
    var foo = require('./foo').bar.bar.bar;
    var fs = require('fs');


  ��� 
    var fs = require('fs');
    var index = require('./');
    var sibling = require('./foo');
    var path = require('path');


  ��� 
    var path = require('path');
    var async = require('async');


  ��� 
    var async = require('async');
    var index = require('./');


  ��� 
    var async = require('async');
    var index = require('./');


  ��� 
    var async = require('async');
    var index = require('./');


  ��� 
    var async = require('async');
    var index = require('./');


  ��� 
    import async, {foo1} from 'async';
    import relParent2, {foo2} from '../foo/bar';
    var fs = require('fs');
    var relParent1 = require('../foo');
    var relParent3 = require('../');
    import sibling, {foo3} from './foo';
    var index = require('./');


  ��� 
    var fs = require('fs');
    import async, {foo1} from 'async';
    import relParent2, {foo2} from '../foo/bar';


  ��� 
    var fs = require('fs');
    var index = require('./');
    var path = require('path');

    var sibling = require('./foo');

    var relParent1 = require('../foo');
    var relParent3 = require('../');
    var async = require('async');
   (39ms)

  ��� 
    var fs = require('fs');
    var index = require('./');
    var path = require('path');
    var sibling = require('./foo');
    var relParent1 = require('../foo');
    var relParent3 = require('../');
    var async = require('async');


  ��� 
    var fs = require('fs');

    var path = require('path');
    var index = require('./');

    var sibling = require('./foo');

    var async = require('async');


  ��� 
    import path from 'path';
    import 'loud-rejection';

    import 'something-else';
    import _ from 'lodash';


  ��� 
    import path from 'path';
    import 'loud-rejection';
    import 'something-else';
    import _ from 'lodash';

prefer-default-export
valid

  ��� 
    export const foo = 'foo';
    export const bar = 'bar';

  ��� 
    export default function bar() {};

  ��� 
    export const foo = 'foo';
    export function bar() {};

  ��� 
    export const foo = 'foo';
    export default bar;

  ��� 
    export { foo, bar }

  ��� 
    export const { foo, bar } = item;

  ��� 
    export const { foo, bar: baz } = item;

  ��� 
    export const { foo: { bar, baz } } = item;

  ��� 
    export const foo = item;
    export { item };

  ��� 
    export { foo as default }

  ��� 
    export * from './foo';

  ��� 
    import * as foo from './foo';
invalid

  ��� 
    export function bar() {};

  ��� 
    export const foo = 'foo';

  ��� 
    const foo = 'foo';
    export { foo };

  ��� 
    export const { foo } = { foo: "bar" };

  ��� 
    export const { foo: { bar } } = { foo: { bar: "baz" } };

781 passing (11s)

--------------------------------|----------|----------|----------|----------|----------------|

File % Stmts % Branch % Funcs % Lines Uncovered Lines
All files 94.64 89.76 97.46 95.68
config 100 100 100 100
electron.js 100 100 100 100
errors.js 100 100 100 100
react-native.js 100 100 100 100
react.js 100 100 100 100
stage-0.js 100 100 100 100
warnings.js 100 100 100 100
src 100 100 100 100
importDeclaration.js 100 100 100 100
index.js 100 100 100 100
src/core 88.4 81.25 95.12 90.14
declaredScope.js 85.71 75 100 100
getExports.js 94.42 86.51 95.35 95.74 ... 330,332,333
hash.js 100 100 100 100
ignore.js 100 100 100 100
importType.js 100 100 100 100
module-require.js 72.73 100 100 72.73 20,22,26
parse.js 80 50 100 100
resolve.js 69.66 56 86.67 71.6 ... 136,137,152
staticRequire.js 100 100 100 100
src/rules 97.61 94.43 100 98.15
default.js 100 100 100 100
export.js 97.44 95.65 100 100
extensions.js 100 95.45 100 100
imports-first.js 100 94.12 100 100
named.js 100 100 100 100
namespace.js 94.81 95.24 100 93.75 89,90,94,158
newline-after-import.js 100 100 100 100
no-amd.js 100 100 100 100
no-commonjs.js 100 100 100 100
no-deprecated.js 93.42 90 100 98.31 49
no-duplicates.js 100 100 100 100
no-extraneous-dependencies.js 92.11 81.08 100 92.11 9,21,79
no-mutable-exports.js 100 92.86 100 100
no-named-as-default-member.js 93.75 94.12 100 93.1 28,29
no-named-as-default.js 100 100 100 100
no-namespace.js 100 100 100 100
no-nodejs-modules.js 100 75 100 100
no-restricted-paths.js 95.24 66.67 100 95.24 22
no-unresolved.js 100 100 100 100
order.js 100 97.83 100 100
prefer-default-export.js 100 100 100 100
tests/files 100 100 100 100
foo-bar-resolver.js 100 100 100 100
issue210.config.js 100 100 100 100
webpack.config.js 100 100 100 100
webpack.empty.config.js 100 100 100 100
tests/src 93.33 75 100 100
cli.js 100 100 100 100
package.js 90.32 50 100 100
utils.js 100 100 100 100
tests/src/core 94.51 50 94.38 95.08
getExports.js 100 100 100 100
importType.js 100 100 100 100
parse.js 92.31 50 100 100
resolve.js 72.92 50 76.19 73.91 ... 83,87,88,89
tests/src/rules 100 100 100 100
default.js 100 100 100 100
export.js 100 100 100 100
extensions.js 100 100 100 100
imports-first.js 100 100 100 100
named.js 100 100 100 100
namespace.js 100 100 100 100
newline-after-import.js 100 100 100 100
no-amd.js 100 100 100 100
no-commonjs.js 100 100 100 100
no-deprecated.js 100 100 100 100
no-duplicates.js 100 100 100 100
no-extraneous-dependencies.js 100 100 100 100
no-mutable-exports.js 100 100 100 100
no-named-as-default-member.js 100 100 100 100
no-named-as-default.js 100 100 100 100
no-namespace.js 100 100 100 100
no-nodejs-modules.js 100 100 100 100
no-restricted-paths.js 100 100 100 100
no-unresolved.js 100 100 100 100
order.js 100 100 100 100
prefer-default-export.js 100 100 100 100
-------------------------------- ---------- ---------- ---------- ---------- ----------------

eslint-plugin-import@1.12.0 posttest /var/lib/jenkins/workspace/Regression Build/eslint-plugin-import
eslint ./src

Cannot read property 'isPropertyDefined' of null
TypeError: Cannot read property 'isPropertyDefined' of null
at EventEmitter.Property (/var/lib/jenkins/workspace/Regression Build/eslint-plugin-import/node_modules/eslint/lib/rules/no-dupe-keys.js:116:25)
at emitOne (events.js:77:13)
at EventEmitter.emit (events.js:169:7)
at NodeEventGenerator.enterNode (/var/lib/jenkins/workspace/Regression Build/eslint-plugin-import/node_modules/eslint/lib/util/node-event-generator.js:40:22)
at CodePathAnalyzer.enterNode (/var/lib/jenkins/workspace/Regression Build/eslint-plugin-import/node_modules/eslint/lib/code-path-analysis/code-path-analyzer.js:608:23)
at CommentEventGenerator.enterNode (/var/lib/jenkins/workspace/Regression Build/eslint-plugin-import/node_modules/eslint/lib/util/comment-event-generator.js:97:23)
at Controller.traverser.traverse.enter (/var/lib/jenkins/workspace/Regression Build/eslint-plugin-import/node_modules/eslint/lib/eslint.js:895:36)
at Controller.__execute (/var/lib/jenkins/workspace/Regression Build/eslint-plugin-import/node_modules/eslint/node_modules/estraverse/estraverse.js:397:31)
at Controller.traverse (/var/lib/jenkins/workspace/Regression Build/eslint-plugin-import/node_modules/eslint/node_modules/estraverse/estraverse.js:501:28)
at Controller.Traverser.controller.traverse (/var/lib/jenkins/workspace/Regression Build/eslint-plugin-import/node_modules/eslint/lib/util/traverser.js:36:33)

npm ERR! Linux 3.16.0-4-amd64
npm ERR! argv "/usr/bin/nodejs" "/usr/bin/npm" "run" "test"
npm ERR! node v4.4.7
npm ERR! npm v2.15.8
npm ERR! code ELIFECYCLE
npm ERR! eslint-plugin-import@1.12.0 posttest: eslint ./src
npm ERR! Exit status 1
npm ERR!
npm ERR! Failed at the eslint-plugin-import@1.12.0 posttest script 'eslint ./src'.
npm ERR! This is most likely a problem with the eslint-plugin-import package,
npm ERR! not with npm itself.
npm ERR! Tell the author that this fails on your system:
npm ERR! eslint ./src
npm ERR! You can get information on how to open an issue for this project with:
npm ERR! npm bugs eslint-plugin-import
npm ERR! Or if that isn't available, you can get their info via:
npm ERR!
npm ERR! npm owner ls eslint-plugin-import
npm ERR! There is likely additional logging output above.

@mysticatea Could you take a quick look please?
@ilyavolodin ilyavolodin added bug ESLint is working incorrectly rule Relates to ESLint's core rules accepted There is consensus among the team that this change meets the criteria for inclusion labels Aug 11, 2016
@mysticatea
Copy link
Member

Wow, thanks for good catch!

mysticatea added a commit that referenced this issue Aug 12, 2016
@mysticatea
Fix: no-dupe-keys type errors (fixes #6886)
1081088
@mysticatea mysticatea mentioned this issue Aug 12, 2016
Merged
ilyavolodin pushed a commit that referenced this issue Aug 12, 2016
@mysticatea @ilyavolodin
Fix: no-dupe-keys type errors (fixes #6886) (#6889)
055742c
@mysticatea mysticatea mentioned this issue Aug 13, 2016
Closed
@eslint-deprecated eslint-deprecated bot locked and limited conversation to collaborators Feb 6, 2018
@eslint-deprecated eslint-deprecated bot added the archived due to age This issue has been archived; please open a new issue for any further discussion label Feb 6, 2018
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Assignees
No one assigned
Labels
accepted There is consensus among the team that this change meets the criteria for inclusion archived due to age This issue has been archived; please open a new issue for any further discussion bug ESLint is working incorrectly rule Relates to ESLint's core rules
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
2 participants
@ilyavolodin @mysticatea