From 317a828a2fd4fb2ea2072fb50f7dc161a36584d3 Mon Sep 17 00:00:00 2001
From: Pierre-Marie <p.dartus@salesforce.com>
Date: Sat, 3 Feb 2018 10:40:45 -0800
Subject: [PATCH] Close gaps in scope and linter tests

---
 types/eslint/eslint-tests.ts | 103 +++++++++++++++++++++++++++++++----
 types/eslint/index.d.ts      |   2 +-
 2 files changed, 92 insertions(+), 13 deletions(-)

diff --git a/types/eslint/eslint-tests.ts b/types/eslint/eslint-tests.ts
index 5f15b21039..57a58d475e 100644
--- a/types/eslint/eslint-tests.ts
+++ b/types/eslint/eslint-tests.ts
@@ -1,5 +1,5 @@
 import { Comment } from 'estree';
-import { AST, SourceCode, Rule, Linter, CLIEngine, RuleTester } from 'eslint';
+import { AST, SourceCode, Rule, Linter, CLIEngine, RuleTester, Scope } from 'eslint';
 
 const SOURCE = `var foo = bar;`;
 
@@ -38,7 +38,7 @@ const COMMENT: Comment = {
 
 //#region SourceCode
 
-const sourceCode = new SourceCode(SOURCE, AST);
+let sourceCode = new SourceCode(SOURCE, AST);
 
 SourceCode.splitLines(SOURCE);
 
@@ -210,6 +210,48 @@ sourceCode.getCommentsInside(AST);
 
 //#endregion
 
+//#region Scope
+
+const scopeManager: Scope.ScopeManager = {
+    scopes: [],
+    globalScope: null,
+    acquire(node, inner) {
+        return this.scopes[0];
+    },
+    getDeclaredVariables() {
+        return [];
+    }
+};
+
+const scope = scopeManager.scopes[0];
+
+const variable = scope.variables[0];
+
+variable.name = 'foo';
+
+variable.identifiers[0].type = 'Identifier';
+
+variable.defs[0].name.type = 'Identifier';
+variable.defs[0].type;
+variable.defs[0].node;
+variable.defs[0].parent;
+
+const reference = scope.references[0];
+
+reference.from = scope;
+reference.identifier.type = 'Identifier';
+reference.resolved = variable;
+reference.writeExpr = AST;
+reference.init = true;
+
+reference.isRead();
+reference.isReadOnly();
+reference.isWrite();
+reference.isWriteOnly();
+reference.isReadWrite();
+
+//#endregion
+
 //#region Rule
 
 let rule: Rule.RuleModule;
@@ -326,27 +368,64 @@ linter.verify(SOURCE, { rules: { 'no-console': 'error' } }, 'test.js');
 linter.verify(SOURCE, { rules: { 'no-console': 'warn' } }, 'test.js');
 linter.verify(SOURCE, { rules: { 'no-console': 'off' } }, 'test.js');
 
+const lintingResult = linter.verify(SOURCE, {});
+
+for (const msg of lintingResult) {
+    msg.severity = 1;
+    msg.severity = 2;
+
+    msg.ruleId = 'foo';
+
+    msg.fatal = true;
+
+    msg.line = 0;
+    msg.endLine = 0;
+    msg.column = 0;
+    msg.endColumn = 0;
+
+    msg.source = SOURCE;
+
+    if (msg.fix) {
+        msg.fix.text = 'foo';
+        msg.fix.range = [0, 0];
+    }
+}
+
 linter.verifyAndFix(SOURCE, {});
 linter.verifyAndFix(SOURCE, {}, 'test.js');
 linter.verifyAndFix(SOURCE, {}, { fix: false });
 
-linter.getSourceCode();
+const fixResult = linter.verifyAndFix(SOURCE, {});
 
-// TODO: Fix me
-linter.defineRule('test', {
-    create() => {},
-});
+fixResult.fixed = true;
+fixResult.output = 'foo';
+
+for (const msg of fixResult.messages) {
+    msg.ruleId = 'foo';
+}
+
+sourceCode = linter.getSourceCode();
+
+linter.defineRule('test', rule);
 
-// TODO: Fix me
 linter.defineRules({
-    'test': { create() => {} },
-    'test-2': { create() => {} },
+    foo: rule,
+    bar: rule,
 });
 
 linter.getRules();
 
-// TODO: Fix me
-linter.defineParser('cutom-parser', );
+linter.defineParser('custom-parser', { parse: (src, opts) => AST });
+linter.defineParser('custom-parser', {
+    parseForESLint(src, opts) {
+        return {
+            ast: AST,
+            visitorKeys: {},
+            parserServices: {},
+            scopeManager,
+        };
+    }
+});
 
 //#endregion
 
diff --git a/types/eslint/index.d.ts b/types/eslint/index.d.ts
index 26f2452fe2..4ba910329c 100644
--- a/types/eslint/index.d.ts
+++ b/types/eslint/index.d.ts
@@ -69,7 +69,7 @@ export namespace Scope {
 
     interface Variable {
         name: string;
-        identifiers: ESTree.Identifier;
+        identifiers: ESTree.Identifier[];
         references: Reference[];
         defs: Definition[];
     }